/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * 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.accumulo.core.tabletserver.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 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;
  
  @SuppressWarnings("all") public class TabletClientService {
  
    public interface Iface extends org.apache.accumulo.core.client.impl.thrift.ClientService.Iface {
  
      public org.apache.accumulo.core.data.thrift.InitialScan startScan(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.accumulo.core.data.thrift.TKeyExtent extent, org.apache.accumulo.core.data.thrift.TRange range, List<org.apache.accumulo.core.data.thrift.TColumn> columns, int batchSize, List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList, Map<String,Map<String,String>> ssio, List<ByteBuffer> authorizations, boolean waitForWrites, boolean isolated) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, NotServingTabletException, TooManyFilesException, org.apache.thrift.TException;
  
      public org.apache.accumulo.core.data.thrift.ScanResult continueScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID) throws NoSuchScanIDException, NotServingTabletException, TooManyFilesException, org.apache.thrift.TException;
  
      public void closeScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID) throws org.apache.thrift.TException;
  
      public org.apache.accumulo.core.data.thrift.InitialMultiScan startMultiScan(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, Map<org.apache.accumulo.core.data.thrift.TKeyExtent,List<org.apache.accumulo.core.data.thrift.TRange>> batch, List<org.apache.accumulo.core.data.thrift.TColumn> columns, List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList, Map<String,Map<String,String>> ssio, List<ByteBuffer> authorizations, boolean waitForWrites) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException;
  
      public org.apache.accumulo.core.data.thrift.MultiScanResult continueMultiScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID) throws NoSuchScanIDException, org.apache.thrift.TException;
  
      public void closeMultiScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID) throws NoSuchScanIDException, org.apache.thrift.TException;
  
      public long startUpdate(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException;
  
      public void applyUpdates(org.apache.accumulo.trace.thrift.TInfo tinfo, long updateID, org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent, List<org.apache.accumulo.core.data.thrift.TMutation> mutations) throws org.apache.thrift.TException;
  
      public org.apache.accumulo.core.data.thrift.UpdateErrors closeUpdate(org.apache.accumulo.trace.thrift.TInfo tinfo, long updateID) throws NoSuchScanIDException, org.apache.thrift.TException;
  
      public void update(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent, org.apache.accumulo.core.data.thrift.TMutation mutation) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, NotServingTabletException, ConstraintViolationException, org.apache.thrift.TException;
  
      public List<org.apache.accumulo.core.data.thrift.TKeyExtent> bulkImport(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, long tid, Map<org.apache.accumulo.core.data.thrift.TKeyExtent,Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo>> files, boolean setTime) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException;
  
      public void splitTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.accumulo.core.data.thrift.TKeyExtent extent, ByteBuffer splitPoint) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, NotServingTabletException, org.apache.thrift.TException;
  
      public void loadTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent) throws org.apache.thrift.TException;
  
      public void unloadTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent, boolean save) throws org.apache.thrift.TException;
  
      public void flush(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, String tableId, ByteBuffer startRow, ByteBuffer endRow) throws org.apache.thrift.TException;
  
      public void flushTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent) throws org.apache.thrift.TException;
  
      public void chop(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent) throws org.apache.thrift.TException;
  
      public void compact(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, String tableId, ByteBuffer startRow, ByteBuffer endRow) throws org.apache.thrift.TException;
  
      public org.apache.accumulo.core.master.thrift.TabletServerStatus getTabletServerStatus(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException;
  
      public List<TabletStats> getTabletStats(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String tableId) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException;
  
      public TabletStats getHistoricalStats(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException;
  
      public void halt(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException;
  
      public void fastHalt(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock) throws org.apache.thrift.TException;
  
      public List<ActiveScan> getActiveScans(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException;
 
     public List<ActiveCompaction> getActiveCompactions(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException;
 
     public void removeLogs(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, List<String> filenames) throws org.apache.thrift.TException;
 
   }
 
   public interface AsyncIface extends org.apache.accumulo.core.client.impl.thrift.ClientService .AsyncIface {
 
     public void startScan(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.accumulo.core.data.thrift.TKeyExtent extent, org.apache.accumulo.core.data.thrift.TRange range, List<org.apache.accumulo.core.data.thrift.TColumn> columns, int batchSize, List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList, Map<String,Map<String,String>> ssio, List<ByteBuffer> authorizations, boolean waitForWrites, boolean isolated, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.startScan_call> resultHandler) throws org.apache.thrift.TException;
 
     public void continueScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.continueScan_call> resultHandler) throws org.apache.thrift.TException;
 
     public void closeScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.closeScan_call> resultHandler) throws org.apache.thrift.TException;
 
     public void startMultiScan(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, Map<org.apache.accumulo.core.data.thrift.TKeyExtent,List<org.apache.accumulo.core.data.thrift.TRange>> batch, List<org.apache.accumulo.core.data.thrift.TColumn> columns, List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList, Map<String,Map<String,String>> ssio, List<ByteBuffer> authorizations, boolean waitForWrites, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.startMultiScan_call> resultHandler) throws org.apache.thrift.TException;
 
     public void continueMultiScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.continueMultiScan_call> resultHandler) throws org.apache.thrift.TException;
 
     public void closeMultiScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.closeMultiScan_call> resultHandler) throws org.apache.thrift.TException;
 
     public void startUpdate(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.startUpdate_call> resultHandler) throws org.apache.thrift.TException;
 
     public void applyUpdates(org.apache.accumulo.trace.thrift.TInfo tinfo, long updateID, org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent, List<org.apache.accumulo.core.data.thrift.TMutation> mutations, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.applyUpdates_call> resultHandler) throws org.apache.thrift.TException;
 
     public void closeUpdate(org.apache.accumulo.trace.thrift.TInfo tinfo, long updateID, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.closeUpdate_call> resultHandler) throws org.apache.thrift.TException;
 
     public void update(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent, org.apache.accumulo.core.data.thrift.TMutation mutation, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.update_call> resultHandler) throws org.apache.thrift.TException;
 
     public void bulkImport(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, long tid, Map<org.apache.accumulo.core.data.thrift.TKeyExtent,Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo>> files, boolean setTime, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.bulkImport_call> resultHandler) throws org.apache.thrift.TException;
 
     public void splitTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.accumulo.core.data.thrift.TKeyExtent extent, ByteBuffer splitPoint, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.splitTablet_call> resultHandler) throws org.apache.thrift.TException;
 
     public void loadTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.loadTablet_call> resultHandler) throws org.apache.thrift.TException;
 
     public void unloadTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent, boolean save, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.unloadTablet_call> resultHandler) throws org.apache.thrift.TException;
 
     public void flush(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, String tableId, ByteBuffer startRow, ByteBuffer endRow, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.flush_call> resultHandler) throws org.apache.thrift.TException;
 
     public void flushTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.flushTablet_call> resultHandler) throws org.apache.thrift.TException;
 
     public void chop(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.chop_call> resultHandler) throws org.apache.thrift.TException;
 
     public void compact(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, String tableId, ByteBuffer startRow, ByteBuffer endRow, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.compact_call> resultHandler) throws org.apache.thrift.TException;
 
     public void getTabletServerStatus(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getTabletServerStatus_call> resultHandler) throws org.apache.thrift.TException;
 
     public void getTabletStats(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String tableId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getTabletStats_call> resultHandler) throws org.apache.thrift.TException;
 
     public void getHistoricalStats(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getHistoricalStats_call> resultHandler) throws org.apache.thrift.TException;
 
     public void halt(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.halt_call> resultHandler) throws org.apache.thrift.TException;
 
     public void fastHalt(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.fastHalt_call> resultHandler) throws org.apache.thrift.TException;
 
     public void getActiveScans(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getActiveScans_call> resultHandler) throws org.apache.thrift.TException;
 
     public void getActiveCompactions(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getActiveCompactions_call> resultHandler) throws org.apache.thrift.TException;
 
     public void removeLogs(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, List<String> filenames, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.removeLogs_call> resultHandler) throws org.apache.thrift.TException;
 
   }
 
   public static class Client extends org.apache.accumulo.core.client.impl.thrift.ClientService.Client implements Iface {
     public static class Factory implements org.apache.thrift.TServiceClientFactory<Client> {
       public Factory() {}
       public Client getClient(org.apache.thrift.protocol.TProtocol prot) {
         return new Client(prot);
       }
       public Client getClient(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
         return new Client(iprot, oprot);
       }
     }
 
     public Client(org.apache.thrift.protocol.TProtocol prot)
     {
       super(prot, prot);
     }
 
     public Client(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
       super(iprot, oprot);
     }
 
     public org.apache.accumulo.core.data.thrift.InitialScan startScan(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.accumulo.core.data.thrift.TKeyExtent extent, org.apache.accumulo.core.data.thrift.TRange range, List<org.apache.accumulo.core.data.thrift.TColumn> columns, int batchSize, List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList, Map<String,Map<String,String>> ssio, List<ByteBuffer> authorizations, boolean waitForWrites, boolean isolated) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, NotServingTabletException, TooManyFilesException, org.apache.thrift.TException
     {
       send_startScan(tinfo, credential, extent, range, columns, batchSize, ssiList, ssio, authorizations, waitForWrites, isolated);
       return recv_startScan();
     }
 
     public void send_startScan(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.accumulo.core.data.thrift.TKeyExtent extent, org.apache.accumulo.core.data.thrift.TRange range, List<org.apache.accumulo.core.data.thrift.TColumn> columns, int batchSize, List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList, Map<String,Map<String,String>> ssio, List<ByteBuffer> authorizations, boolean waitForWrites, boolean isolated) throws org.apache.thrift.TException
     {
       startScan_args args = new startScan_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       args.setExtent(extent);
       args.setRange(range);
       args.setColumns(columns);
       args.setBatchSize(batchSize);
       args.setSsiList(ssiList);
       args.setSsio(ssio);
       args.setAuthorizations(authorizations);
       args.setWaitForWrites(waitForWrites);
       args.setIsolated(isolated);
       sendBase("startScan", args);
     }
 
     public org.apache.accumulo.core.data.thrift.InitialScan recv_startScan() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, NotServingTabletException, TooManyFilesException, org.apache.thrift.TException
     {
       startScan_result result = new startScan_result();
       receiveBase(result, "startScan");
       if (result.isSetSuccess()) {
         return result.success;
       }
       if (result.sec != null) {
         throw result.sec;
       }
       if (result.nste != null) {
         throw result.nste;
       }
       if (result.tmfe != null) {
         throw result.tmfe;
       }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "startScan failed: unknown result");
     }
 
     public org.apache.accumulo.core.data.thrift.ScanResult continueScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID) throws NoSuchScanIDException, NotServingTabletException, TooManyFilesException, org.apache.thrift.TException
     {
       send_continueScan(tinfo, scanID);
       return recv_continueScan();
     }
 
     public void send_continueScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID) throws org.apache.thrift.TException
     {
       continueScan_args args = new continueScan_args();
       args.setTinfo(tinfo);
       args.setScanID(scanID);
       sendBase("continueScan", args);
     }
 
     public org.apache.accumulo.core.data.thrift.ScanResult recv_continueScan() throws NoSuchScanIDException, NotServingTabletException, TooManyFilesException, org.apache.thrift.TException
     {
       continueScan_result result = new continueScan_result();
       receiveBase(result, "continueScan");
       if (result.isSetSuccess()) {
         return result.success;
       }
       if (result.nssi != null) {
         throw result.nssi;
       }
       if (result.nste != null) {
         throw result.nste;
       }
       if (result.tmfe != null) {
         throw result.tmfe;
       }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "continueScan failed: unknown result");
     }
 
     public void closeScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID) throws org.apache.thrift.TException
     {
       send_closeScan(tinfo, scanID);
     }
 
     public void send_closeScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID) throws org.apache.thrift.TException
     {
       closeScan_args args = new closeScan_args();
       args.setTinfo(tinfo);
       args.setScanID(scanID);
       sendBase("closeScan", args);
     }
 
     public org.apache.accumulo.core.data.thrift.InitialMultiScan startMultiScan(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, Map<org.apache.accumulo.core.data.thrift.TKeyExtent,List<org.apache.accumulo.core.data.thrift.TRange>> batch, List<org.apache.accumulo.core.data.thrift.TColumn> columns, List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList, Map<String,Map<String,String>> ssio, List<ByteBuffer> authorizations, boolean waitForWrites) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException
     {
       send_startMultiScan(tinfo, credential, batch, columns, ssiList, ssio, authorizations, waitForWrites);
       return recv_startMultiScan();
     }
 
     public void send_startMultiScan(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, Map<org.apache.accumulo.core.data.thrift.TKeyExtent,List<org.apache.accumulo.core.data.thrift.TRange>> batch, List<org.apache.accumulo.core.data.thrift.TColumn> columns, List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList, Map<String,Map<String,String>> ssio, List<ByteBuffer> authorizations, boolean waitForWrites) throws org.apache.thrift.TException
     {
       startMultiScan_args args = new startMultiScan_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       args.setBatch(batch);
       args.setColumns(columns);
       args.setSsiList(ssiList);
       args.setSsio(ssio);
       args.setAuthorizations(authorizations);
       args.setWaitForWrites(waitForWrites);
       sendBase("startMultiScan", args);
     }
 
     public org.apache.accumulo.core.data.thrift.InitialMultiScan recv_startMultiScan() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException
     {
       startMultiScan_result result = new startMultiScan_result();
       receiveBase(result, "startMultiScan");
       if (result.isSetSuccess()) {
         return result.success;
       }
       if (result.sec != null) {
         throw result.sec;
       }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "startMultiScan failed: unknown result");
     }
 
     public org.apache.accumulo.core.data.thrift.MultiScanResult continueMultiScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID) throws NoSuchScanIDException, org.apache.thrift.TException
     {
       send_continueMultiScan(tinfo, scanID);
       return recv_continueMultiScan();
     }
 
     public void send_continueMultiScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID) throws org.apache.thrift.TException
     {
       continueMultiScan_args args = new continueMultiScan_args();
       args.setTinfo(tinfo);
       args.setScanID(scanID);
       sendBase("continueMultiScan", args);
     }
 
     public org.apache.accumulo.core.data.thrift.MultiScanResult recv_continueMultiScan() throws NoSuchScanIDException, org.apache.thrift.TException
     {
       continueMultiScan_result result = new continueMultiScan_result();
       receiveBase(result, "continueMultiScan");
       if (result.isSetSuccess()) {
         return result.success;
       }
       if (result.nssi != null) {
         throw result.nssi;
       }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "continueMultiScan failed: unknown result");
     }
 
     public void closeMultiScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID) throws NoSuchScanIDException, org.apache.thrift.TException
     {
       send_closeMultiScan(tinfo, scanID);
       recv_closeMultiScan();
     }
 
     public void send_closeMultiScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID) throws org.apache.thrift.TException
     {
       closeMultiScan_args args = new closeMultiScan_args();
       args.setTinfo(tinfo);
       args.setScanID(scanID);
       sendBase("closeMultiScan", args);
     }
 
     public void recv_closeMultiScan() throws NoSuchScanIDException, org.apache.thrift.TException
     {
       closeMultiScan_result result = new closeMultiScan_result();
       receiveBase(result, "closeMultiScan");
       if (result.nssi != null) {
         throw result.nssi;
       }
       return;
     }
 
     public long startUpdate(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException
     {
       send_startUpdate(tinfo, credential);
       return recv_startUpdate();
     }
 
     public void send_startUpdate(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential) throws org.apache.thrift.TException
     {
       startUpdate_args args = new startUpdate_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       sendBase("startUpdate", args);
     }
 
     public long recv_startUpdate() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException
     {
       startUpdate_result result = new startUpdate_result();
       receiveBase(result, "startUpdate");
       if (result.isSetSuccess()) {
         return result.success;
       }
       if (result.sec != null) {
         throw result.sec;
       }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "startUpdate failed: unknown result");
     }
 
     public void applyUpdates(org.apache.accumulo.trace.thrift.TInfo tinfo, long updateID, org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent, List<org.apache.accumulo.core.data.thrift.TMutation> mutations) throws org.apache.thrift.TException
     {
       send_applyUpdates(tinfo, updateID, keyExtent, mutations);
     }
 
     public void send_applyUpdates(org.apache.accumulo.trace.thrift.TInfo tinfo, long updateID, org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent, List<org.apache.accumulo.core.data.thrift.TMutation> mutations) throws org.apache.thrift.TException
     {
       applyUpdates_args args = new applyUpdates_args();
       args.setTinfo(tinfo);
       args.setUpdateID(updateID);
       args.setKeyExtent(keyExtent);
       args.setMutations(mutations);
       sendBase("applyUpdates", args);
     }
 
     public org.apache.accumulo.core.data.thrift.UpdateErrors closeUpdate(org.apache.accumulo.trace.thrift.TInfo tinfo, long updateID) throws NoSuchScanIDException, org.apache.thrift.TException
     {
       send_closeUpdate(tinfo, updateID);
       return recv_closeUpdate();
     }
 
     public void send_closeUpdate(org.apache.accumulo.trace.thrift.TInfo tinfo, long updateID) throws org.apache.thrift.TException
     {
       closeUpdate_args args = new closeUpdate_args();
       args.setTinfo(tinfo);
       args.setUpdateID(updateID);
       sendBase("closeUpdate", args);
     }
 
     public org.apache.accumulo.core.data.thrift.UpdateErrors recv_closeUpdate() throws NoSuchScanIDException, org.apache.thrift.TException
     {
       closeUpdate_result result = new closeUpdate_result();
       receiveBase(result, "closeUpdate");
       if (result.isSetSuccess()) {
         return result.success;
       }
       if (result.nssi != null) {
         throw result.nssi;
       }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "closeUpdate failed: unknown result");
     }
 
     public void update(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent, org.apache.accumulo.core.data.thrift.TMutation mutation) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, NotServingTabletException, ConstraintViolationException, org.apache.thrift.TException
     {
       send_update(tinfo, credential, keyExtent, mutation);
       recv_update();
     }
 
     public void send_update(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent, org.apache.accumulo.core.data.thrift.TMutation mutation) throws org.apache.thrift.TException
     {
       update_args args = new update_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       args.setKeyExtent(keyExtent);
       args.setMutation(mutation);
       sendBase("update", args);
     }
 
     public void recv_update() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, NotServingTabletException, ConstraintViolationException, org.apache.thrift.TException
     {
       update_result result = new update_result();
       receiveBase(result, "update");
       if (result.sec != null) {
         throw result.sec;
       }
       if (result.nste != null) {
         throw result.nste;
       }
       if (result.cve != null) {
         throw result.cve;
       }
       return;
     }
 
     public List<org.apache.accumulo.core.data.thrift.TKeyExtent> bulkImport(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, long tid, Map<org.apache.accumulo.core.data.thrift.TKeyExtent,Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo>> files, boolean setTime) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException
     {
       send_bulkImport(tinfo, credential, tid, files, setTime);
       return recv_bulkImport();
     }
 
     public void send_bulkImport(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, long tid, Map<org.apache.accumulo.core.data.thrift.TKeyExtent,Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo>> files, boolean setTime) throws org.apache.thrift.TException
     {
       bulkImport_args args = new bulkImport_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       args.setTid(tid);
       args.setFiles(files);
       args.setSetTime(setTime);
       sendBase("bulkImport", args);
     }
 
     public List<org.apache.accumulo.core.data.thrift.TKeyExtent> recv_bulkImport() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException
     {
       bulkImport_result result = new bulkImport_result();
       receiveBase(result, "bulkImport");
       if (result.isSetSuccess()) {
         return result.success;
       }
       if (result.sec != null) {
         throw result.sec;
       }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "bulkImport failed: unknown result");
     }
 
     public void splitTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.accumulo.core.data.thrift.TKeyExtent extent, ByteBuffer splitPoint) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, NotServingTabletException, org.apache.thrift.TException
     {
       send_splitTablet(tinfo, credential, extent, splitPoint);
       recv_splitTablet();
     }
 
     public void send_splitTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.accumulo.core.data.thrift.TKeyExtent extent, ByteBuffer splitPoint) throws org.apache.thrift.TException
     {
       splitTablet_args args = new splitTablet_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       args.setExtent(extent);
       args.setSplitPoint(splitPoint);
       sendBase("splitTablet", args);
     }
 
     public void recv_splitTablet() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, NotServingTabletException, org.apache.thrift.TException
     {
       splitTablet_result result = new splitTablet_result();
       receiveBase(result, "splitTablet");
       if (result.sec != null) {
         throw result.sec;
       }
       if (result.nste != null) {
         throw result.nste;
       }
       return;
     }
 
     public void loadTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent) throws org.apache.thrift.TException
     {
       send_loadTablet(tinfo, credential, lock, extent);
     }
 
     public void send_loadTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent) throws org.apache.thrift.TException
     {
       loadTablet_args args = new loadTablet_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       args.setLock(lock);
       args.setExtent(extent);
       sendBase("loadTablet", args);
     }
 
     public void unloadTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent, boolean save) throws org.apache.thrift.TException
     {
       send_unloadTablet(tinfo, credential, lock, extent, save);
     }
 
     public void send_unloadTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent, boolean save) throws org.apache.thrift.TException
     {
       unloadTablet_args args = new unloadTablet_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       args.setLock(lock);
       args.setExtent(extent);
       args.setSave(save);
       sendBase("unloadTablet", args);
     }
 
     public void flush(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, String tableId, ByteBuffer startRow, ByteBuffer endRow) throws org.apache.thrift.TException
     {
       send_flush(tinfo, credential, lock, tableId, startRow, endRow);
     }
 
     public void send_flush(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, String tableId, ByteBuffer startRow, ByteBuffer endRow) throws org.apache.thrift.TException
     {
       flush_args args = new flush_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       args.setLock(lock);
       args.setTableId(tableId);
       args.setStartRow(startRow);
       args.setEndRow(endRow);
       sendBase("flush", args);
     }
 
     public void flushTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent) throws org.apache.thrift.TException
     {
       send_flushTablet(tinfo, credential, lock, extent);
     }
 
     public void send_flushTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent) throws org.apache.thrift.TException
     {
       flushTablet_args args = new flushTablet_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       args.setLock(lock);
       args.setExtent(extent);
       sendBase("flushTablet", args);
     }
 
     public void chop(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent) throws org.apache.thrift.TException
     {
       send_chop(tinfo, credential, lock, extent);
     }
 
     public void send_chop(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent) throws org.apache.thrift.TException
     {
       chop_args args = new chop_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       args.setLock(lock);
       args.setExtent(extent);
       sendBase("chop", args);
     }
 
     public void compact(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, String tableId, ByteBuffer startRow, ByteBuffer endRow) throws org.apache.thrift.TException
     {
       send_compact(tinfo, credential, lock, tableId, startRow, endRow);
     }
 
     public void send_compact(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, String tableId, ByteBuffer startRow, ByteBuffer endRow) throws org.apache.thrift.TException
     {
       compact_args args = new compact_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       args.setLock(lock);
       args.setTableId(tableId);
       args.setStartRow(startRow);
       args.setEndRow(endRow);
       sendBase("compact", args);
     }
 
     public org.apache.accumulo.core.master.thrift.TabletServerStatus getTabletServerStatus(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException
     {
       send_getTabletServerStatus(tinfo, credential);
       return recv_getTabletServerStatus();
     }
 
     public void send_getTabletServerStatus(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential) throws org.apache.thrift.TException
     {
       getTabletServerStatus_args args = new getTabletServerStatus_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       sendBase("getTabletServerStatus", args);
     }
 
     public org.apache.accumulo.core.master.thrift.TabletServerStatus recv_getTabletServerStatus() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException
     {
       getTabletServerStatus_result result = new getTabletServerStatus_result();
       receiveBase(result, "getTabletServerStatus");
       if (result.isSetSuccess()) {
         return result.success;
       }
       if (result.sec != null) {
         throw result.sec;
       }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getTabletServerStatus failed: unknown result");
     }
 
     public List<TabletStats> getTabletStats(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String tableId) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException
     {
       send_getTabletStats(tinfo, credential, tableId);
       return recv_getTabletStats();
     }
 
     public void send_getTabletStats(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String tableId) throws org.apache.thrift.TException
     {
       getTabletStats_args args = new getTabletStats_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       args.setTableId(tableId);
       sendBase("getTabletStats", args);
     }
 
     public List<TabletStats> recv_getTabletStats() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException
     {
       getTabletStats_result result = new getTabletStats_result();
       receiveBase(result, "getTabletStats");
       if (result.isSetSuccess()) {
         return result.success;
       }
       if (result.sec != null) {
         throw result.sec;
       }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getTabletStats failed: unknown result");
     }
 
     public TabletStats getHistoricalStats(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException
     {
       send_getHistoricalStats(tinfo, credential);
       return recv_getHistoricalStats();
     }
 
     public void send_getHistoricalStats(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential) throws org.apache.thrift.TException
     {
       getHistoricalStats_args args = new getHistoricalStats_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       sendBase("getHistoricalStats", args);
     }
 
     public TabletStats recv_getHistoricalStats() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException
     {
       getHistoricalStats_result result = new getHistoricalStats_result();
       receiveBase(result, "getHistoricalStats");
       if (result.isSetSuccess()) {
         return result.success;
       }
       if (result.sec != null) {
         throw result.sec;
       }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getHistoricalStats failed: unknown result");
     }
 
     public void halt(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException
     {
       send_halt(tinfo, credential, lock);
       recv_halt();
     }
 
     public void send_halt(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock) throws org.apache.thrift.TException
     {
       halt_args args = new halt_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       args.setLock(lock);
       sendBase("halt", args);
     }
 
     public void recv_halt() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException
     {
       halt_result result = new halt_result();
       receiveBase(result, "halt");
       if (result.sec != null) {
         throw result.sec;
       }
       return;
     }
 
     public void fastHalt(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock) throws org.apache.thrift.TException
     {
       send_fastHalt(tinfo, credential, lock);
     }
 
     public void send_fastHalt(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock) throws org.apache.thrift.TException
     {
       fastHalt_args args = new fastHalt_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       args.setLock(lock);
       sendBase("fastHalt", args);
     }
 
     public List<ActiveScan> getActiveScans(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException
     {
       send_getActiveScans(tinfo, credential);
       return recv_getActiveScans();
     }
 
     public void send_getActiveScans(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential) throws org.apache.thrift.TException
     {
       getActiveScans_args args = new getActiveScans_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       sendBase("getActiveScans", args);
     }
 
     public List<ActiveScan> recv_getActiveScans() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException
     {
       getActiveScans_result result = new getActiveScans_result();
       receiveBase(result, "getActiveScans");
       if (result.isSetSuccess()) {
         return result.success;
       }
       if (result.sec != null) {
         throw result.sec;
       }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getActiveScans failed: unknown result");
     }
 
     public List<ActiveCompaction> getActiveCompactions(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential) throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException
     {
       send_getActiveCompactions(tinfo, credential);
       return recv_getActiveCompactions();
     }
 
     public void send_getActiveCompactions(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential) throws org.apache.thrift.TException
     {
       getActiveCompactions_args args = new getActiveCompactions_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       sendBase("getActiveCompactions", args);
     }
 
     public List<ActiveCompaction> recv_getActiveCompactions() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException
     {
       getActiveCompactions_result result = new getActiveCompactions_result();
       receiveBase(result, "getActiveCompactions");
       if (result.isSetSuccess()) {
         return result.success;
       }
       if (result.sec != null) {
         throw result.sec;
       }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getActiveCompactions failed: unknown result");
     }
 
     public void removeLogs(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, List<String> filenames) throws org.apache.thrift.TException
     {
       send_removeLogs(tinfo, credential, filenames);
     }
 
     public void send_removeLogs(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, List<String> filenames) throws org.apache.thrift.TException
     {
       removeLogs_args args = new removeLogs_args();
       args.setTinfo(tinfo);
       args.setCredential(credential);
       args.setFilenames(filenames);
       sendBase("removeLogs", args);
     }
 
   }
   public static class AsyncClient extends org.apache.accumulo.core.client.impl.thrift.ClientService.AsyncClient implements AsyncIface {
     public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
       private org.apache.thrift.async.TAsyncClientManager clientManager;
       private org.apache.thrift.protocol.TProtocolFactory protocolFactory;
       public Factory(org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.protocol.TProtocolFactory protocolFactory) {
         this.clientManager = clientManager;
         this.protocolFactory = protocolFactory;
       }
       public AsyncClient getAsyncClient(org.apache.thrift.transport.TNonblockingTransport transport) {
         return new AsyncClient(protocolFactory, clientManager, transport);
       }
     }
 
     public AsyncClient(org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.transport.TNonblockingTransport transport) {
       super(protocolFactory, clientManager, transport);
     }
 
     public void startScan(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.accumulo.core.data.thrift.TKeyExtent extent, org.apache.accumulo.core.data.thrift.TRange range, List<org.apache.accumulo.core.data.thrift.TColumn> columns, int batchSize, List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList, Map<String,Map<String,String>> ssio, List<ByteBuffer> authorizations, boolean waitForWrites, boolean isolated, org.apache.thrift.async.AsyncMethodCallback<startScan_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       startScan_call method_call = new startScan_call(tinfo, credential, extent, range, columns, batchSize, ssiList, ssio, authorizations, waitForWrites, isolated, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class startScan_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       private org.apache.accumulo.core.data.thrift.TKeyExtent extent;
       private org.apache.accumulo.core.data.thrift.TRange range;
       private List<org.apache.accumulo.core.data.thrift.TColumn> columns;
       private int batchSize;
       private List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList;
       private Map<String,Map<String,String>> ssio;
       private List<ByteBuffer> authorizations;
       private boolean waitForWrites;
       private boolean isolated;
       public startScan_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.accumulo.core.data.thrift.TKeyExtent extent, org.apache.accumulo.core.data.thrift.TRange range, List<org.apache.accumulo.core.data.thrift.TColumn> columns, int batchSize, List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList, Map<String,Map<String,String>> ssio, List<ByteBuffer> authorizations, boolean waitForWrites, boolean isolated, org.apache.thrift.async.AsyncMethodCallback<startScan_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, false);
         this.tinfo = tinfo;
         this.credential = credential;
         this.extent = extent;
         this.range = range;
         this.columns = columns;
         this.batchSize = batchSize;
         this.ssiList = ssiList;
         this.ssio = ssio;
         this.authorizations = authorizations;
         this.waitForWrites = waitForWrites;
         this.isolated = isolated;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("startScan", org.apache.thrift.protocol.TMessageType.CALL, 0));
         startScan_args args = new startScan_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.setExtent(extent);
         args.setRange(range);
         args.setColumns(columns);
         args.setBatchSize(batchSize);
         args.setSsiList(ssiList);
         args.setSsio(ssio);
         args.setAuthorizations(authorizations);
         args.setWaitForWrites(waitForWrites);
         args.setIsolated(isolated);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public org.apache.accumulo.core.data.thrift.InitialScan getResult() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, NotServingTabletException, TooManyFilesException, org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_startScan();
       }
     }
 
     public void continueScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID, org.apache.thrift.async.AsyncMethodCallback<continueScan_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       continueScan_call method_call = new continueScan_call(tinfo, scanID, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class continueScan_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private long scanID;
       public continueScan_call(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID, org.apache.thrift.async.AsyncMethodCallback<continueScan_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, false);
         this.tinfo = tinfo;
         this.scanID = scanID;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("continueScan", org.apache.thrift.protocol.TMessageType.CALL, 0));
         continueScan_args args = new continueScan_args();
         args.setTinfo(tinfo);
         args.setScanID(scanID);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public org.apache.accumulo.core.data.thrift.ScanResult getResult() throws NoSuchScanIDException, NotServingTabletException, TooManyFilesException, org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_continueScan();
       }
     }
 
     public void closeScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID, org.apache.thrift.async.AsyncMethodCallback<closeScan_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       closeScan_call method_call = new closeScan_call(tinfo, scanID, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class closeScan_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private long scanID;
       public closeScan_call(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID, org.apache.thrift.async.AsyncMethodCallback<closeScan_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, true);
         this.tinfo = tinfo;
         this.scanID = scanID;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("closeScan", org.apache.thrift.protocol.TMessageType.CALL, 0));
         closeScan_args args = new closeScan_args();
         args.setTinfo(tinfo);
         args.setScanID(scanID);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public void getResult() throws org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
       }
     }
 
     public void startMultiScan(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, Map<org.apache.accumulo.core.data.thrift.TKeyExtent,List<org.apache.accumulo.core.data.thrift.TRange>> batch, List<org.apache.accumulo.core.data.thrift.TColumn> columns, List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList, Map<String,Map<String,String>> ssio, List<ByteBuffer> authorizations, boolean waitForWrites, org.apache.thrift.async.AsyncMethodCallback<startMultiScan_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       startMultiScan_call method_call = new startMultiScan_call(tinfo, credential, batch, columns, ssiList, ssio, authorizations, waitForWrites, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class startMultiScan_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       private Map<org.apache.accumulo.core.data.thrift.TKeyExtent,List<org.apache.accumulo.core.data.thrift.TRange>> batch;
       private List<org.apache.accumulo.core.data.thrift.TColumn> columns;
       private List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList;
       private Map<String,Map<String,String>> ssio;
       private List<ByteBuffer> authorizations;
       private boolean waitForWrites;
       public startMultiScan_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, Map<org.apache.accumulo.core.data.thrift.TKeyExtent,List<org.apache.accumulo.core.data.thrift.TRange>> batch, List<org.apache.accumulo.core.data.thrift.TColumn> columns, List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList, Map<String,Map<String,String>> ssio, List<ByteBuffer> authorizations, boolean waitForWrites, org.apache.thrift.async.AsyncMethodCallback<startMultiScan_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, false);
         this.tinfo = tinfo;
         this.credential = credential;
         this.batch = batch;
         this.columns = columns;
         this.ssiList = ssiList;
         this.ssio = ssio;
         this.authorizations = authorizations;
         this.waitForWrites = waitForWrites;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("startMultiScan", org.apache.thrift.protocol.TMessageType.CALL, 0));
         startMultiScan_args args = new startMultiScan_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.setBatch(batch);
         args.setColumns(columns);
         args.setSsiList(ssiList);
         args.setSsio(ssio);
         args.setAuthorizations(authorizations);
         args.setWaitForWrites(waitForWrites);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public org.apache.accumulo.core.data.thrift.InitialMultiScan getResult() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_startMultiScan();
       }
     }
 
     public void continueMultiScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID, org.apache.thrift.async.AsyncMethodCallback<continueMultiScan_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       continueMultiScan_call method_call = new continueMultiScan_call(tinfo, scanID, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class continueMultiScan_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private long scanID;
       public continueMultiScan_call(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID, org.apache.thrift.async.AsyncMethodCallback<continueMultiScan_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, false);
         this.tinfo = tinfo;
         this.scanID = scanID;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("continueMultiScan", org.apache.thrift.protocol.TMessageType.CALL, 0));
         continueMultiScan_args args = new continueMultiScan_args();
         args.setTinfo(tinfo);
         args.setScanID(scanID);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public org.apache.accumulo.core.data.thrift.MultiScanResult getResult() throws NoSuchScanIDException, org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_continueMultiScan();
       }
     }
 
     public void closeMultiScan(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID, org.apache.thrift.async.AsyncMethodCallback<closeMultiScan_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       closeMultiScan_call method_call = new closeMultiScan_call(tinfo, scanID, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class closeMultiScan_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private long scanID;
       public closeMultiScan_call(org.apache.accumulo.trace.thrift.TInfo tinfo, long scanID, org.apache.thrift.async.AsyncMethodCallback<closeMultiScan_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, false);
         this.tinfo = tinfo;
         this.scanID = scanID;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("closeMultiScan", org.apache.thrift.protocol.TMessageType.CALL, 0));
         closeMultiScan_args args = new closeMultiScan_args();
         args.setTinfo(tinfo);
         args.setScanID(scanID);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public void getResult() throws NoSuchScanIDException, org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         (new Client(prot)).recv_closeMultiScan();
       }
     }
 
     public void startUpdate(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.thrift.async.AsyncMethodCallback<startUpdate_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       startUpdate_call method_call = new startUpdate_call(tinfo, credential, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class startUpdate_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       public startUpdate_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.thrift.async.AsyncMethodCallback<startUpdate_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, false);
         this.tinfo = tinfo;
         this.credential = credential;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("startUpdate", org.apache.thrift.protocol.TMessageType.CALL, 0));
         startUpdate_args args = new startUpdate_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public long getResult() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_startUpdate();
       }
     }
 
     public void applyUpdates(org.apache.accumulo.trace.thrift.TInfo tinfo, long updateID, org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent, List<org.apache.accumulo.core.data.thrift.TMutation> mutations, org.apache.thrift.async.AsyncMethodCallback<applyUpdates_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       applyUpdates_call method_call = new applyUpdates_call(tinfo, updateID, keyExtent, mutations, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class applyUpdates_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private long updateID;
       private org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent;
       private List<org.apache.accumulo.core.data.thrift.TMutation> mutations;
       public applyUpdates_call(org.apache.accumulo.trace.thrift.TInfo tinfo, long updateID, org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent, List<org.apache.accumulo.core.data.thrift.TMutation> mutations, org.apache.thrift.async.AsyncMethodCallback<applyUpdates_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, true);
         this.tinfo = tinfo;
         this.updateID = updateID;
         this.keyExtent = keyExtent;
         this.mutations = mutations;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("applyUpdates", org.apache.thrift.protocol.TMessageType.CALL, 0));
         applyUpdates_args args = new applyUpdates_args();
         args.setTinfo(tinfo);
         args.setUpdateID(updateID);
         args.setKeyExtent(keyExtent);
         args.setMutations(mutations);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public void getResult() throws org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
       }
     }
 
     public void closeUpdate(org.apache.accumulo.trace.thrift.TInfo tinfo, long updateID, org.apache.thrift.async.AsyncMethodCallback<closeUpdate_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       closeUpdate_call method_call = new closeUpdate_call(tinfo, updateID, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class closeUpdate_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private long updateID;
       public closeUpdate_call(org.apache.accumulo.trace.thrift.TInfo tinfo, long updateID, org.apache.thrift.async.AsyncMethodCallback<closeUpdate_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, false);
         this.tinfo = tinfo;
         this.updateID = updateID;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("closeUpdate", org.apache.thrift.protocol.TMessageType.CALL, 0));
         closeUpdate_args args = new closeUpdate_args();
         args.setTinfo(tinfo);
         args.setUpdateID(updateID);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public org.apache.accumulo.core.data.thrift.UpdateErrors getResult() throws NoSuchScanIDException, org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_closeUpdate();
       }
     }
 
     public void update(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent, org.apache.accumulo.core.data.thrift.TMutation mutation, org.apache.thrift.async.AsyncMethodCallback<update_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       update_call method_call = new update_call(tinfo, credential, keyExtent, mutation, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class update_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       private org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent;
       private org.apache.accumulo.core.data.thrift.TMutation mutation;
       public update_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent, org.apache.accumulo.core.data.thrift.TMutation mutation, org.apache.thrift.async.AsyncMethodCallback<update_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, false);
         this.tinfo = tinfo;
         this.credential = credential;
         this.keyExtent = keyExtent;
         this.mutation = mutation;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("update", org.apache.thrift.protocol.TMessageType.CALL, 0));
         update_args args = new update_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.setKeyExtent(keyExtent);
         args.setMutation(mutation);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public void getResult() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, NotServingTabletException, ConstraintViolationException, org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         (new Client(prot)).recv_update();
       }
     }
 
     public void bulkImport(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, long tid, Map<org.apache.accumulo.core.data.thrift.TKeyExtent,Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo>> files, boolean setTime, org.apache.thrift.async.AsyncMethodCallback<bulkImport_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       bulkImport_call method_call = new bulkImport_call(tinfo, credential, tid, files, setTime, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class bulkImport_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       private long tid;
       private Map<org.apache.accumulo.core.data.thrift.TKeyExtent,Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo>> files;
       private boolean setTime;
       public bulkImport_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, long tid, Map<org.apache.accumulo.core.data.thrift.TKeyExtent,Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo>> files, boolean setTime, org.apache.thrift.async.AsyncMethodCallback<bulkImport_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, false);
         this.tinfo = tinfo;
         this.credential = credential;
         this.tid = tid;
         this.files = files;
         this.setTime = setTime;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("bulkImport", org.apache.thrift.protocol.TMessageType.CALL, 0));
         bulkImport_args args = new bulkImport_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.setTid(tid);
         args.setFiles(files);
         args.setSetTime(setTime);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public List<org.apache.accumulo.core.data.thrift.TKeyExtent> getResult() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_bulkImport();
       }
     }
 
     public void splitTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.accumulo.core.data.thrift.TKeyExtent extent, ByteBuffer splitPoint, org.apache.thrift.async.AsyncMethodCallback<splitTablet_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       splitTablet_call method_call = new splitTablet_call(tinfo, credential, extent, splitPoint, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class splitTablet_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       private org.apache.accumulo.core.data.thrift.TKeyExtent extent;
       private ByteBuffer splitPoint;
       public splitTablet_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.accumulo.core.data.thrift.TKeyExtent extent, ByteBuffer splitPoint, org.apache.thrift.async.AsyncMethodCallback<splitTablet_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, false);
         this.tinfo = tinfo;
         this.credential = credential;
         this.extent = extent;
         this.splitPoint = splitPoint;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("splitTablet", org.apache.thrift.protocol.TMessageType.CALL, 0));
         splitTablet_args args = new splitTablet_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.setExtent(extent);
         args.setSplitPoint(splitPoint);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public void getResult() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, NotServingTabletException, org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         (new Client(prot)).recv_splitTablet();
       }
     }
 
     public void loadTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent, org.apache.thrift.async.AsyncMethodCallback<loadTablet_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       loadTablet_call method_call = new loadTablet_call(tinfo, credential, lock, extent, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class loadTablet_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       private String lock;
       private org.apache.accumulo.core.data.thrift.TKeyExtent extent;
       public loadTablet_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent, org.apache.thrift.async.AsyncMethodCallback<loadTablet_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, true);
         this.tinfo = tinfo;
         this.credential = credential;
         this.lock = lock;
         this.extent = extent;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("loadTablet", org.apache.thrift.protocol.TMessageType.CALL, 0));
         loadTablet_args args = new loadTablet_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.setLock(lock);
         args.setExtent(extent);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public void getResult() throws org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
       }
     }
 
     public void unloadTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent, boolean save, org.apache.thrift.async.AsyncMethodCallback<unloadTablet_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       unloadTablet_call method_call = new unloadTablet_call(tinfo, credential, lock, extent, save, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class unloadTablet_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       private String lock;
       private org.apache.accumulo.core.data.thrift.TKeyExtent extent;
       private boolean save;
       public unloadTablet_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent, boolean save, org.apache.thrift.async.AsyncMethodCallback<unloadTablet_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, true);
         this.tinfo = tinfo;
         this.credential = credential;
         this.lock = lock;
         this.extent = extent;
         this.save = save;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("unloadTablet", org.apache.thrift.protocol.TMessageType.CALL, 0));
         unloadTablet_args args = new unloadTablet_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.setLock(lock);
         args.setExtent(extent);
         args.setSave(save);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public void getResult() throws org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
       }
     }
 
     public void flush(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, String tableId, ByteBuffer startRow, ByteBuffer endRow, org.apache.thrift.async.AsyncMethodCallback<flush_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       flush_call method_call = new flush_call(tinfo, credential, lock, tableId, startRow, endRow, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class flush_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       private String lock;
       private String tableId;
       private ByteBuffer startRow;
       private ByteBuffer endRow;
       public flush_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, String tableId, ByteBuffer startRow, ByteBuffer endRow, org.apache.thrift.async.AsyncMethodCallback<flush_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, true);
         this.tinfo = tinfo;
         this.credential = credential;
         this.lock = lock;
         this.tableId = tableId;
         this.startRow = startRow;
         this.endRow = endRow;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("flush", org.apache.thrift.protocol.TMessageType.CALL, 0));
         flush_args args = new flush_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.setLock(lock);
         args.setTableId(tableId);
         args.setStartRow(startRow);
         args.setEndRow(endRow);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public void getResult() throws org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
       }
     }
 
     public void flushTablet(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent, org.apache.thrift.async.AsyncMethodCallback<flushTablet_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       flushTablet_call method_call = new flushTablet_call(tinfo, credential, lock, extent, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class flushTablet_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       private String lock;
       private org.apache.accumulo.core.data.thrift.TKeyExtent extent;
       public flushTablet_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent, org.apache.thrift.async.AsyncMethodCallback<flushTablet_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, true);
         this.tinfo = tinfo;
         this.credential = credential;
         this.lock = lock;
         this.extent = extent;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("flushTablet", org.apache.thrift.protocol.TMessageType.CALL, 0));
         flushTablet_args args = new flushTablet_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.setLock(lock);
         args.setExtent(extent);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public void getResult() throws org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
       }
     }
 
     public void chop(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent, org.apache.thrift.async.AsyncMethodCallback<chop_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       chop_call method_call = new chop_call(tinfo, credential, lock, extent, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class chop_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       private String lock;
       private org.apache.accumulo.core.data.thrift.TKeyExtent extent;
       public chop_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.accumulo.core.data.thrift.TKeyExtent extent, org.apache.thrift.async.AsyncMethodCallback<chop_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, true);
         this.tinfo = tinfo;
         this.credential = credential;
         this.lock = lock;
         this.extent = extent;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("chop", org.apache.thrift.protocol.TMessageType.CALL, 0));
         chop_args args = new chop_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.setLock(lock);
         args.setExtent(extent);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public void getResult() throws org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
       }
     }
 
     public void compact(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, String tableId, ByteBuffer startRow, ByteBuffer endRow, org.apache.thrift.async.AsyncMethodCallback<compact_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       compact_call method_call = new compact_call(tinfo, credential, lock, tableId, startRow, endRow, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class compact_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       private String lock;
       private String tableId;
       private ByteBuffer startRow;
       private ByteBuffer endRow;
       public compact_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, String tableId, ByteBuffer startRow, ByteBuffer endRow, org.apache.thrift.async.AsyncMethodCallback<compact_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, true);
         this.tinfo = tinfo;
         this.credential = credential;
         this.lock = lock;
         this.tableId = tableId;
         this.startRow = startRow;
         this.endRow = endRow;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("compact", org.apache.thrift.protocol.TMessageType.CALL, 0));
         compact_args args = new compact_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.setLock(lock);
         args.setTableId(tableId);
         args.setStartRow(startRow);
         args.setEndRow(endRow);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public void getResult() throws org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
       }
     }
 
     public void getTabletServerStatus(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.thrift.async.AsyncMethodCallback<getTabletServerStatus_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       getTabletServerStatus_call method_call = new getTabletServerStatus_call(tinfo, credential, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class getTabletServerStatus_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       public getTabletServerStatus_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.thrift.async.AsyncMethodCallback<getTabletServerStatus_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, false);
         this.tinfo = tinfo;
         this.credential = credential;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTabletServerStatus", org.apache.thrift.protocol.TMessageType.CALL, 0));
         getTabletServerStatus_args args = new getTabletServerStatus_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public org.apache.accumulo.core.master.thrift.TabletServerStatus getResult() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_getTabletServerStatus();
       }
     }
 
     public void getTabletStats(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String tableId, org.apache.thrift.async.AsyncMethodCallback<getTabletStats_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       getTabletStats_call method_call = new getTabletStats_call(tinfo, credential, tableId, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class getTabletStats_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       private String tableId;
       public getTabletStats_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String tableId, org.apache.thrift.async.AsyncMethodCallback<getTabletStats_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, false);
         this.tinfo = tinfo;
         this.credential = credential;
         this.tableId = tableId;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTabletStats", org.apache.thrift.protocol.TMessageType.CALL, 0));
         getTabletStats_args args = new getTabletStats_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.setTableId(tableId);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public List<TabletStats> getResult() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_getTabletStats();
       }
     }
 
     public void getHistoricalStats(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.thrift.async.AsyncMethodCallback<getHistoricalStats_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       getHistoricalStats_call method_call = new getHistoricalStats_call(tinfo, credential, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class getHistoricalStats_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       public getHistoricalStats_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.thrift.async.AsyncMethodCallback<getHistoricalStats_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, false);
         this.tinfo = tinfo;
         this.credential = credential;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getHistoricalStats", org.apache.thrift.protocol.TMessageType.CALL, 0));
         getHistoricalStats_args args = new getHistoricalStats_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public TabletStats getResult() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_getHistoricalStats();
       }
     }
 
     public void halt(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.thrift.async.AsyncMethodCallback<halt_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       halt_call method_call = new halt_call(tinfo, credential, lock, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class halt_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       private String lock;
       public halt_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.thrift.async.AsyncMethodCallback<halt_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, false);
         this.tinfo = tinfo;
         this.credential = credential;
         this.lock = lock;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("halt", org.apache.thrift.protocol.TMessageType.CALL, 0));
         halt_args args = new halt_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.setLock(lock);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public void getResult() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         (new Client(prot)).recv_halt();
       }
     }
 
     public void fastHalt(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.thrift.async.AsyncMethodCallback<fastHalt_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       fastHalt_call method_call = new fastHalt_call(tinfo, credential, lock, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class fastHalt_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       private String lock;
       public fastHalt_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, String lock, org.apache.thrift.async.AsyncMethodCallback<fastHalt_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, true);
         this.tinfo = tinfo;
         this.credential = credential;
         this.lock = lock;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("fastHalt", org.apache.thrift.protocol.TMessageType.CALL, 0));
         fastHalt_args args = new fastHalt_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.setLock(lock);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public void getResult() throws org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
       }
     }
 
     public void getActiveScans(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.thrift.async.AsyncMethodCallback<getActiveScans_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       getActiveScans_call method_call = new getActiveScans_call(tinfo, credential, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class getActiveScans_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       public getActiveScans_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.thrift.async.AsyncMethodCallback<getActiveScans_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, false);
         this.tinfo = tinfo;
         this.credential = credential;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getActiveScans", org.apache.thrift.protocol.TMessageType.CALL, 0));
         getActiveScans_args args = new getActiveScans_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public List<ActiveScan> getResult() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_getActiveScans();
       }
     }
 
     public void getActiveCompactions(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.thrift.async.AsyncMethodCallback<getActiveCompactions_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       getActiveCompactions_call method_call = new getActiveCompactions_call(tinfo, credential, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class getActiveCompactions_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       public getActiveCompactions_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, org.apache.thrift.async.AsyncMethodCallback<getActiveCompactions_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, false);
         this.tinfo = tinfo;
         this.credential = credential;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getActiveCompactions", org.apache.thrift.protocol.TMessageType.CALL, 0));
         getActiveCompactions_args args = new getActiveCompactions_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public List<ActiveCompaction> getResult() throws org.apache.accumulo.core.security.thrift.ThriftSecurityException, org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_getActiveCompactions();
       }
     }
 
     public void removeLogs(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, List<String> filenames, org.apache.thrift.async.AsyncMethodCallback<removeLogs_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       removeLogs_call method_call = new removeLogs_call(tinfo, credential, filenames, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
     }
 
     public static class removeLogs_call extends org.apache.thrift.async.TAsyncMethodCall {
       private org.apache.accumulo.trace.thrift.TInfo tinfo;
       private org.apache.accumulo.core.security.thrift.Credential credential;
       private List<String> filenames;
       public removeLogs_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.Credential credential, List<String> filenames, org.apache.thrift.async.AsyncMethodCallback<removeLogs_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, true);
         this.tinfo = tinfo;
         this.credential = credential;
         this.filenames = filenames;
       }
 
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("removeLogs", org.apache.thrift.protocol.TMessageType.CALL, 0));
         removeLogs_args args = new removeLogs_args();
         args.setTinfo(tinfo);
         args.setCredential(credential);
         args.setFilenames(filenames);
         args.write(prot);
         prot.writeMessageEnd();
       }
 
       public void getResult() throws org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
         }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
       }
     }
 
   }
 
   public static class Processor<I extends Iface> extends org.apache.accumulo.core.client.impl.thrift.ClientService.Processor<I> implements org.apache.thrift.TProcessor {
     private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
     public Processor(I iface) {
       super(iface, getProcessMap(new HashMap<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>>()));
     }
 
     protected Processor(I iface, Map<String,  org.apache.thrift.ProcessFunction<I, ? extends  org.apache.thrift.TBase>> processMap) {
       super(iface, getProcessMap(processMap));
     }
 
     private static <I extends Iface> Map<String,  org.apache.thrift.ProcessFunction<I, ? extends  org.apache.thrift.TBase>> getProcessMap(Map<String,  org.apache.thrift.ProcessFunction<I, ? extends  org.apache.thrift.TBase>> processMap) {
       processMap.put("startScan", new startScan());
       processMap.put("continueScan", new continueScan());
       processMap.put("closeScan", new closeScan());
       processMap.put("startMultiScan", new startMultiScan());
       processMap.put("continueMultiScan", new continueMultiScan());
       processMap.put("closeMultiScan", new closeMultiScan());
       processMap.put("startUpdate", new startUpdate());
       processMap.put("applyUpdates", new applyUpdates());
       processMap.put("closeUpdate", new closeUpdate());
       processMap.put("update", new update());
       processMap.put("bulkImport", new bulkImport());
       processMap.put("splitTablet", new splitTablet());
       processMap.put("loadTablet", new loadTablet());
       processMap.put("unloadTablet", new unloadTablet());
       processMap.put("flush", new flush());
       processMap.put("flushTablet", new flushTablet());
       processMap.put("chop", new chop());
       processMap.put("compact", new compact());
       processMap.put("getTabletServerStatus", new getTabletServerStatus());
       processMap.put("getTabletStats", new getTabletStats());
       processMap.put("getHistoricalStats", new getHistoricalStats());
       processMap.put("halt", new halt());
       processMap.put("fastHalt", new fastHalt());
       processMap.put("getActiveScans", new getActiveScans());
       processMap.put("getActiveCompactions", new getActiveCompactions());
       processMap.put("removeLogs", new removeLogs());
       return processMap;
     }
 
     public static class startScan<I extends Iface> extends org.apache.thrift.ProcessFunction<I, startScan_args> {
       public startScan() {
         super("startScan");
       }
 
       public startScan_args getEmptyArgsInstance() {
         return new startScan_args();
       }
 
       protected boolean isOneway() {
         return false;
       }
 
       public startScan_result getResult(I iface, startScan_args args) throws org.apache.thrift.TException {
         startScan_result result = new startScan_result();
         try {
           result.success = iface.startScan(args.tinfo, args.credential, args.extent, args.range, args.columns, args.batchSize, args.ssiList, args.ssio, args.authorizations, args.waitForWrites, args.isolated);
         } catch (org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
           result.sec = sec;
         } catch (NotServingTabletException nste) {
           result.nste = nste;
         } catch (TooManyFilesException tmfe) {
           result.tmfe = tmfe;
         }
         return result;
       }
     }
 
     public static class continueScan<I extends Iface> extends org.apache.thrift.ProcessFunction<I, continueScan_args> {
       public continueScan() {
         super("continueScan");
       }
 
       public continueScan_args getEmptyArgsInstance() {
         return new continueScan_args();
       }
 
       protected boolean isOneway() {
         return false;
       }
 
       public continueScan_result getResult(I iface, continueScan_args args) throws org.apache.thrift.TException {
         continueScan_result result = new continueScan_result();
         try {
           result.success = iface.continueScan(args.tinfo, args.scanID);
         } catch (NoSuchScanIDException nssi) {
           result.nssi = nssi;
         } catch (NotServingTabletException nste) {
           result.nste = nste;
         } catch (TooManyFilesException tmfe) {
           result.tmfe = tmfe;
         }
         return result;
       }
     }
 
     public static class closeScan<I extends Iface> extends org.apache.thrift.ProcessFunction<I, closeScan_args> {
       public closeScan() {
         super("closeScan");
       }
 
       public closeScan_args getEmptyArgsInstance() {
         return new closeScan_args();
       }
 
       protected boolean isOneway() {
         return true;
       }
 
       public org.apache.thrift.TBase getResult(I iface, closeScan_args args) throws org.apache.thrift.TException {
         iface.closeScan(args.tinfo, args.scanID);
         return null;
       }
     }
 
     public static class startMultiScan<I extends Iface> extends org.apache.thrift.ProcessFunction<I, startMultiScan_args> {
       public startMultiScan() {
         super("startMultiScan");
       }
 
       public startMultiScan_args getEmptyArgsInstance() {
         return new startMultiScan_args();
       }
 
       protected boolean isOneway() {
         return false;
       }
 
       public startMultiScan_result getResult(I iface, startMultiScan_args args) throws org.apache.thrift.TException {
         startMultiScan_result result = new startMultiScan_result();
         try {
           result.success = iface.startMultiScan(args.tinfo, args.credential, args.batch, args.columns, args.ssiList, args.ssio, args.authorizations, args.waitForWrites);
         } catch (org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
           result.sec = sec;
         }
         return result;
       }
     }
 
     public static class continueMultiScan<I extends Iface> extends org.apache.thrift.ProcessFunction<I, continueMultiScan_args> {
       public continueMultiScan() {
         super("continueMultiScan");
       }
 
       public continueMultiScan_args getEmptyArgsInstance() {
         return new continueMultiScan_args();
       }
 
       protected boolean isOneway() {
         return false;
       }
 
       public continueMultiScan_result getResult(I iface, continueMultiScan_args args) throws org.apache.thrift.TException {
         continueMultiScan_result result = new continueMultiScan_result();
         try {
           result.success = iface.continueMultiScan(args.tinfo, args.scanID);
         } catch (NoSuchScanIDException nssi) {
           result.nssi = nssi;
         }
         return result;
       }
     }
 
     public static class closeMultiScan<I extends Iface> extends org.apache.thrift.ProcessFunction<I, closeMultiScan_args> {
       public closeMultiScan() {
         super("closeMultiScan");
       }
 
       public closeMultiScan_args getEmptyArgsInstance() {
         return new closeMultiScan_args();
       }
 
       protected boolean isOneway() {
         return false;
       }
 
       public closeMultiScan_result getResult(I iface, closeMultiScan_args args) throws org.apache.thrift.TException {
         closeMultiScan_result result = new closeMultiScan_result();
         try {
           iface.closeMultiScan(args.tinfo, args.scanID);
         } catch (NoSuchScanIDException nssi) {
           result.nssi = nssi;
         }
         return result;
       }
     }
 
     public static class startUpdate<I extends Iface> extends org.apache.thrift.ProcessFunction<I, startUpdate_args> {
       public startUpdate() {
         super("startUpdate");
       }
 
       public startUpdate_args getEmptyArgsInstance() {
         return new startUpdate_args();
       }
 
       protected boolean isOneway() {
         return false;
       }
 
       public startUpdate_result getResult(I iface, startUpdate_args args) throws org.apache.thrift.TException {
         startUpdate_result result = new startUpdate_result();
         try {
           result.success = iface.startUpdate(args.tinfo, args.credential);
           result.setSuccessIsSet(true);
         } catch (org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
           result.sec = sec;
         }
         return result;
       }
     }
 
     public static class applyUpdates<I extends Iface> extends org.apache.thrift.ProcessFunction<I, applyUpdates_args> {
       public applyUpdates() {
         super("applyUpdates");
       }
 
       public applyUpdates_args getEmptyArgsInstance() {
         return new applyUpdates_args();
       }
 
       protected boolean isOneway() {
         return true;
       }
 
       public org.apache.thrift.TBase getResult(I iface, applyUpdates_args args) throws org.apache.thrift.TException {
         iface.applyUpdates(args.tinfo, args.updateID, args.keyExtent, args.mutations);
         return null;
       }
     }
 
     public static class closeUpdate<I extends Iface> extends org.apache.thrift.ProcessFunction<I, closeUpdate_args> {
       public closeUpdate() {
         super("closeUpdate");
       }
 
       public closeUpdate_args getEmptyArgsInstance() {
         return new closeUpdate_args();
       }
 
       protected boolean isOneway() {
         return false;
       }
 
       public closeUpdate_result getResult(I iface, closeUpdate_args args) throws org.apache.thrift.TException {
         closeUpdate_result result = new closeUpdate_result();
         try {
           result.success = iface.closeUpdate(args.tinfo, args.updateID);
         } catch (NoSuchScanIDException nssi) {
           result.nssi = nssi;
         }
         return result;
       }
     }
 
     public static class update<I extends Iface> extends org.apache.thrift.ProcessFunction<I, update_args> {
       public update() {
         super("update");
       }
 
       public update_args getEmptyArgsInstance() {
         return new update_args();
       }
 
       protected boolean isOneway() {
         return false;
       }
 
       public update_result getResult(I iface, update_args args) throws org.apache.thrift.TException {
         update_result result = new update_result();
         try {
           iface.update(args.tinfo, args.credential, args.keyExtent, args.mutation);
         } catch (org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
           result.sec = sec;
         } catch (NotServingTabletException nste) {
           result.nste = nste;
         } catch (ConstraintViolationException cve) {
           result.cve = cve;
         }
         return result;
       }
     }
 
     public static class bulkImport<I extends Iface> extends org.apache.thrift.ProcessFunction<I, bulkImport_args> {
       public bulkImport() {
         super("bulkImport");
       }
 
       public bulkImport_args getEmptyArgsInstance() {
         return new bulkImport_args();
       }
 
       protected boolean isOneway() {
         return false;
       }
 
       public bulkImport_result getResult(I iface, bulkImport_args args) throws org.apache.thrift.TException {
         bulkImport_result result = new bulkImport_result();
         try {
           result.success = iface.bulkImport(args.tinfo, args.credential, args.tid, args.files, args.setTime);
         } catch (org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
           result.sec = sec;
         }
         return result;
       }
     }
 
     public static class splitTablet<I extends Iface> extends org.apache.thrift.ProcessFunction<I, splitTablet_args> {
       public splitTablet() {
         super("splitTablet");
       }
 
       public splitTablet_args getEmptyArgsInstance() {
         return new splitTablet_args();
       }
 
       protected boolean isOneway() {
         return false;
       }
 
       public splitTablet_result getResult(I iface, splitTablet_args args) throws org.apache.thrift.TException {
         splitTablet_result result = new splitTablet_result();
         try {
           iface.splitTablet(args.tinfo, args.credential, args.extent, args.splitPoint);
         } catch (org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
           result.sec = sec;
         } catch (NotServingTabletException nste) {
           result.nste = nste;
         }
         return result;
       }
     }
 
     public static class loadTablet<I extends Iface> extends org.apache.thrift.ProcessFunction<I, loadTablet_args> {
       public loadTablet() {
         super("loadTablet");
       }
 
       public loadTablet_args getEmptyArgsInstance() {
         return new loadTablet_args();
       }
 
       protected boolean isOneway() {
         return true;
       }
 
       public org.apache.thrift.TBase getResult(I iface, loadTablet_args args) throws org.apache.thrift.TException {
         iface.loadTablet(args.tinfo, args.credential, args.lock, args.extent);
         return null;
       }
     }
 
     public static class unloadTablet<I extends Iface> extends org.apache.thrift.ProcessFunction<I, unloadTablet_args> {
       public unloadTablet() {
         super("unloadTablet");
       }
 
       public unloadTablet_args getEmptyArgsInstance() {
         return new unloadTablet_args();
       }
 
       protected boolean isOneway() {
         return true;
       }
 
       public org.apache.thrift.TBase getResult(I iface, unloadTablet_args args) throws org.apache.thrift.TException {
         iface.unloadTablet(args.tinfo, args.credential, args.lock, args.extent, args.save);
         return null;
       }
     }
 
     public static class flush<I extends Iface> extends org.apache.thrift.ProcessFunction<I, flush_args> {
       public flush() {
         super("flush");
       }
 
       public flush_args getEmptyArgsInstance() {
         return new flush_args();
       }
 
       protected boolean isOneway() {
         return true;
       }
 
       public org.apache.thrift.TBase getResult(I iface, flush_args args) throws org.apache.thrift.TException {
         iface.flush(args.tinfo, args.credential, args.lock, args.tableId, args.startRow, args.endRow);
         return null;
       }
     }
 
     public static class flushTablet<I extends Iface> extends org.apache.thrift.ProcessFunction<I, flushTablet_args> {
       public flushTablet() {
         super("flushTablet");
       }
 
       public flushTablet_args getEmptyArgsInstance() {
         return new flushTablet_args();
       }
 
       protected boolean isOneway() {
         return true;
       }
 
       public org.apache.thrift.TBase getResult(I iface, flushTablet_args args) throws org.apache.thrift.TException {
         iface.flushTablet(args.tinfo, args.credential, args.lock, args.extent);
         return null;
       }
     }
 
     public static class chop<I extends Iface> extends org.apache.thrift.ProcessFunction<I, chop_args> {
       public chop() {
         super("chop");
       }
 
       public chop_args getEmptyArgsInstance() {
         return new chop_args();
       }
 
       protected boolean isOneway() {
         return true;
       }
 
       public org.apache.thrift.TBase getResult(I iface, chop_args args) throws org.apache.thrift.TException {
         iface.chop(args.tinfo, args.credential, args.lock, args.extent);
         return null;
       }
     }
 
     public static class compact<I extends Iface> extends org.apache.thrift.ProcessFunction<I, compact_args> {
       public compact() {
         super("compact");
       }
 
       public compact_args getEmptyArgsInstance() {
         return new compact_args();
       }
 
       protected boolean isOneway() {
         return true;
       }
 
       public org.apache.thrift.TBase getResult(I iface, compact_args args) throws org.apache.thrift.TException {
         iface.compact(args.tinfo, args.credential, args.lock, args.tableId, args.startRow, args.endRow);
         return null;
       }
     }
 
     public static class getTabletServerStatus<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getTabletServerStatus_args> {
       public getTabletServerStatus() {
         super("getTabletServerStatus");
       }
 
       public getTabletServerStatus_args getEmptyArgsInstance() {
         return new getTabletServerStatus_args();
       }
 
       protected boolean isOneway() {
         return false;
       }
 
       public getTabletServerStatus_result getResult(I iface, getTabletServerStatus_args args) throws org.apache.thrift.TException {
         getTabletServerStatus_result result = new getTabletServerStatus_result();
         try {
           result.success = iface.getTabletServerStatus(args.tinfo, args.credential);
         } catch (org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
           result.sec = sec;
         }
         return result;
       }
     }
 
     public static class getTabletStats<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getTabletStats_args> {
       public getTabletStats() {
         super("getTabletStats");
       }
 
       public getTabletStats_args getEmptyArgsInstance() {
         return new getTabletStats_args();
       }
 
       protected boolean isOneway() {
         return false;
       }
 
       public getTabletStats_result getResult(I iface, getTabletStats_args args) throws org.apache.thrift.TException {
         getTabletStats_result result = new getTabletStats_result();
         try {
           result.success = iface.getTabletStats(args.tinfo, args.credential, args.tableId);
         } catch (org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
           result.sec = sec;
         }
         return result;
       }
     }
 
     public static class getHistoricalStats<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getHistoricalStats_args> {
       public getHistoricalStats() {
         super("getHistoricalStats");
       }
 
       public getHistoricalStats_args getEmptyArgsInstance() {
         return new getHistoricalStats_args();
       }
 
       protected boolean isOneway() {
         return false;
       }
 
       public getHistoricalStats_result getResult(I iface, getHistoricalStats_args args) throws org.apache.thrift.TException {
         getHistoricalStats_result result = new getHistoricalStats_result();
         try {
           result.success = iface.getHistoricalStats(args.tinfo, args.credential);
         } catch (org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
           result.sec = sec;
         }
         return result;
       }
     }
 
     public static class halt<I extends Iface> extends org.apache.thrift.ProcessFunction<I, halt_args> {
       public halt() {
         super("halt");
       }
 
       public halt_args getEmptyArgsInstance() {
         return new halt_args();
       }
 
       protected boolean isOneway() {
         return false;
       }
 
       public halt_result getResult(I iface, halt_args args) throws org.apache.thrift.TException {
         halt_result result = new halt_result();
         try {
           iface.halt(args.tinfo, args.credential, args.lock);
         } catch (org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
           result.sec = sec;
         }
         return result;
       }
     }
 
     public static class fastHalt<I extends Iface> extends org.apache.thrift.ProcessFunction<I, fastHalt_args> {
       public fastHalt() {
         super("fastHalt");
       }
 
       public fastHalt_args getEmptyArgsInstance() {
         return new fastHalt_args();
       }
 
       protected boolean isOneway() {
         return true;
       }
 
       public org.apache.thrift.TBase getResult(I iface, fastHalt_args args) throws org.apache.thrift.TException {
         iface.fastHalt(args.tinfo, args.credential, args.lock);
         return null;
       }
     }
 
     public static class getActiveScans<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getActiveScans_args> {
       public getActiveScans() {
         super("getActiveScans");
       }
 
       public getActiveScans_args getEmptyArgsInstance() {
         return new getActiveScans_args();
       }
 
       protected boolean isOneway() {
         return false;
       }
 
       public getActiveScans_result getResult(I iface, getActiveScans_args args) throws org.apache.thrift.TException {
         getActiveScans_result result = new getActiveScans_result();
         try {
           result.success = iface.getActiveScans(args.tinfo, args.credential);
         } catch (org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
           result.sec = sec;
         }
         return result;
       }
     }
 
     public static class getActiveCompactions<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getActiveCompactions_args> {
       public getActiveCompactions() {
         super("getActiveCompactions");
       }
 
       public getActiveCompactions_args getEmptyArgsInstance() {
         return new getActiveCompactions_args();
       }
 
       protected boolean isOneway() {
         return false;
       }
 
       public getActiveCompactions_result getResult(I iface, getActiveCompactions_args args) throws org.apache.thrift.TException {
         getActiveCompactions_result result = new getActiveCompactions_result();
         try {
           result.success = iface.getActiveCompactions(args.tinfo, args.credential);
         } catch (org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
           result.sec = sec;
         }
         return result;
       }
     }
 
     public static class removeLogs<I extends Iface> extends org.apache.thrift.ProcessFunction<I, removeLogs_args> {
       public removeLogs() {
         super("removeLogs");
       }
 
       public removeLogs_args getEmptyArgsInstance() {
         return new removeLogs_args();
       }
 
       protected boolean isOneway() {
         return true;
       }
 
       public org.apache.thrift.TBase getResult(I iface, removeLogs_args args) throws org.apache.thrift.TException {
         iface.removeLogs(args.tinfo, args.credential, args.filenames);
         return null;
       }
     }
 
   }
 
   public static class startScan_args implements org.apache.thrift.TBase<startScan_args, startScan_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("startScan_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)11);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField EXTENT_FIELD_DESC = new org.apache.thrift.protocol.TField("extent", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField RANGE_FIELD_DESC = new org.apache.thrift.protocol.TField("range", org.apache.thrift.protocol.TType.STRUCT, (short)3);
     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)4);
     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)5);
     private static final org.apache.thrift.protocol.TField SSI_LIST_FIELD_DESC = new org.apache.thrift.protocol.TField("ssiList", org.apache.thrift.protocol.TType.LIST, (short)6);
     private static final org.apache.thrift.protocol.TField SSIO_FIELD_DESC = new org.apache.thrift.protocol.TField("ssio", org.apache.thrift.protocol.TType.MAP, (short)7);
     private static final org.apache.thrift.protocol.TField AUTHORIZATIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("authorizations", org.apache.thrift.protocol.TType.LIST, (short)8);
     private static final org.apache.thrift.protocol.TField WAIT_FOR_WRITES_FIELD_DESC = new org.apache.thrift.protocol.TField("waitForWrites", org.apache.thrift.protocol.TType.BOOL, (short)9);
     private static final org.apache.thrift.protocol.TField ISOLATED_FIELD_DESC = new org.apache.thrift.protocol.TField("isolated", org.apache.thrift.protocol.TType.BOOL, (short)10);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new startScan_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new startScan_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
     public org.apache.accumulo.core.data.thrift.TKeyExtent extent; // required
     public org.apache.accumulo.core.data.thrift.TRange range; // required
     public List<org.apache.accumulo.core.data.thrift.TColumn> columns; // required
     public int batchSize; // required
     public List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList; // required
     public Map<String,Map<String,String>> ssio; // required
     public List<ByteBuffer> authorizations; // required
     public boolean waitForWrites; // required
     public boolean isolated; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)11, "tinfo"),
       CREDENTIAL((short)1, "credential"),
       EXTENT((short)2, "extent"),
       RANGE((short)3, "range"),
       COLUMNS((short)4, "columns"),
       BATCH_SIZE((short)5, "batchSize"),
       SSI_LIST((short)6, "ssiList"),
       SSIO((short)7, "ssio"),
       AUTHORIZATIONS((short)8, "authorizations"),
       WAIT_FOR_WRITES((short)9, "waitForWrites"),
       ISOLATED((short)10, "isolated");
 
       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 11: // TINFO
             return TINFO;
           case 1: // CREDENTIAL
             return CREDENTIAL;
           case 2: // EXTENT
             return EXTENT;
           case 3: // RANGE
             return RANGE;
           case 4: // COLUMNS
             return COLUMNS;
           case 5: // BATCH_SIZE
             return BATCH_SIZE;
           case 6: // SSI_LIST
             return SSI_LIST;
           case 7: // SSIO
             return SSIO;
           case 8: // AUTHORIZATIONS
             return AUTHORIZATIONS;
           case 9: // WAIT_FOR_WRITES
             return WAIT_FOR_WRITES;
           case 10: // ISOLATED
             return ISOLATED;
           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 __BATCHSIZE_ISSET_ID = 0;
     private static final int __WAITFORWRITES_ISSET_ID = 1;
     private static final int __ISOLATED_ISSET_ID = 2;
     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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       tmpMap.put(_Fields.EXTENT, new org.apache.thrift.meta_data.FieldMetaData("extent", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.data.thrift.TKeyExtent.class)));
       tmpMap.put(_Fields.RANGE, new org.apache.thrift.meta_data.FieldMetaData("range", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.data.thrift.TRange.class)));
       tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           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, org.apache.accumulo.core.data.thrift.TColumn.class))));
       tmpMap.put(_Fields.BATCH_SIZE, new org.apache.thrift.meta_data.FieldMetaData("batchSize", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
       tmpMap.put(_Fields.SSI_LIST, new org.apache.thrift.meta_data.FieldMetaData("ssiList", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           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, org.apache.accumulo.core.data.thrift.IterInfo.class))));
       tmpMap.put(_Fields.SSIO, new org.apache.thrift.meta_data.FieldMetaData("ssio", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, 
               new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), 
               new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, 
                   new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), 
                   new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))));
       tmpMap.put(_Fields.AUTHORIZATIONS, new org.apache.thrift.meta_data.FieldMetaData("authorizations", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
               new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING              , true))));
       tmpMap.put(_Fields.WAIT_FOR_WRITES, new org.apache.thrift.meta_data.FieldMetaData("waitForWrites", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
       tmpMap.put(_Fields.ISOLATED, new org.apache.thrift.meta_data.FieldMetaData("isolated", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(startScan_args.class, metaDataMap);
     }
 
     public startScan_args() {
     }
 
     public startScan_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential,
       org.apache.accumulo.core.data.thrift.TKeyExtent extent,
       org.apache.accumulo.core.data.thrift.TRange range,
       List<org.apache.accumulo.core.data.thrift.TColumn> columns,
       int batchSize,
       List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList,
       Map<String,Map<String,String>> ssio,
       List<ByteBuffer> authorizations,
       boolean waitForWrites,
       boolean isolated)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
       this.extent = extent;
       this.range = range;
       this.columns = columns;
       this.batchSize = batchSize;
       setBatchSizeIsSet(true);
       this.ssiList = ssiList;
       this.ssio = ssio;
       this.authorizations = authorizations;
       this.waitForWrites = waitForWrites;
       setWaitForWritesIsSet(true);
       this.isolated = isolated;
       setIsolatedIsSet(true);
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public startScan_args(startScan_args other) {
       __isset_bitfield = other.__isset_bitfield;
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
       if (other.isSetExtent()) {
         this.extent = new org.apache.accumulo.core.data.thrift.TKeyExtent(other.extent);
       }
       if (other.isSetRange()) {
         this.range = new org.apache.accumulo.core.data.thrift.TRange(other.range);
       }
       if (other.isSetColumns()) {
         List<org.apache.accumulo.core.data.thrift.TColumn> __this__columns = new ArrayList<org.apache.accumulo.core.data.thrift.TColumn>();
         for (org.apache.accumulo.core.data.thrift.TColumn other_element : other.columns) {
           __this__columns.add(new org.apache.accumulo.core.data.thrift.TColumn(other_element));
         }
         this.columns = __this__columns;
       }
       this.batchSize = other.batchSize;
       if (other.isSetSsiList()) {
         List<org.apache.accumulo.core.data.thrift.IterInfo> __this__ssiList = new ArrayList<org.apache.accumulo.core.data.thrift.IterInfo>();
         for (org.apache.accumulo.core.data.thrift.IterInfo other_element : other.ssiList) {
           __this__ssiList.add(new org.apache.accumulo.core.data.thrift.IterInfo(other_element));
         }
         this.ssiList = __this__ssiList;
       }
       if (other.isSetSsio()) {
         Map<String,Map<String,String>> __this__ssio = new HashMap<String,Map<String,String>>();
         for (Map.Entry<String, Map<String,String>> other_element : other.ssio.entrySet()) {
 
           String other_element_key = other_element.getKey();
           Map<String,String> other_element_value = other_element.getValue();
 
           String __this__ssio_copy_key = other_element_key;
 
           Map<String,String> __this__ssio_copy_value = new HashMap<String,String>();
           for (Map.Entry<String, String> other_element_value_element : other_element_value.entrySet()) {
 
             String other_element_value_element_key = other_element_value_element.getKey();
             String other_element_value_element_value = other_element_value_element.getValue();
 
             String __this__ssio_copy_value_copy_key = other_element_value_element_key;
 
             String __this__ssio_copy_value_copy_value = other_element_value_element_value;
 
             __this__ssio_copy_value.put(__this__ssio_copy_value_copy_key, __this__ssio_copy_value_copy_value);
           }
 
           __this__ssio.put(__this__ssio_copy_key, __this__ssio_copy_value);
         }
         this.ssio = __this__ssio;
       }
       if (other.isSetAuthorizations()) {
         List<ByteBuffer> __this__authorizations = new ArrayList<ByteBuffer>();
         for (ByteBuffer other_element : other.authorizations) {
           ByteBuffer temp_binary_element = org.apache.thrift.TBaseHelper.copyBinary(other_element);
 ;
           __this__authorizations.add(temp_binary_element);
         }
         this.authorizations = __this__authorizations;
       }
       this.waitForWrites = other.waitForWrites;
       this.isolated = other.isolated;
     }
 
     public startScan_args deepCopy() {
       return new startScan_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
       this.extent = null;
       this.range = null;
       this.columns = null;
       setBatchSizeIsSet(false);
       this.batchSize = 0;
       this.ssiList = null;
       this.ssio = null;
       this.authorizations = null;
       setWaitForWritesIsSet(false);
       this.waitForWrites = false;
       setIsolatedIsSet(false);
       this.isolated = false;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public startScan_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public startScan_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public org.apache.accumulo.core.data.thrift.TKeyExtent getExtent() {
       return this.extent;
     }
 
     public startScan_args setExtent(org.apache.accumulo.core.data.thrift.TKeyExtent extent) {
       this.extent = extent;
       return this;
     }
 
     public void unsetExtent() {
       this.extent = null;
     }
 
     /** Returns true if field extent is set (has been assigned a value) and false otherwise */
     public boolean isSetExtent() {
       return this.extent != null;
     }
 
     public void setExtentIsSet(boolean value) {
       if (!value) {
         this.extent = null;
       }
     }
 
     public org.apache.accumulo.core.data.thrift.TRange getRange() {
       return this.range;
     }
 
     public startScan_args setRange(org.apache.accumulo.core.data.thrift.TRange range) {
       this.range = range;
       return this;
     }
 
     public void unsetRange() {
       this.range = null;
     }
 
     /** Returns true if field range is set (has been assigned a value) and false otherwise */
     public boolean isSetRange() {
       return this.range != null;
     }
 
     public void setRangeIsSet(boolean value) {
       if (!value) {
         this.range = null;
       }
     }
 
     public int getColumnsSize() {
       return (this.columns == null) ? 0 : this.columns.size();
     }
 
     public java.util.Iterator<org.apache.accumulo.core.data.thrift.TColumn> getColumnsIterator() {
       return (this.columns == null) ? null : this.columns.iterator();
     }
 
     public void addToColumns(org.apache.accumulo.core.data.thrift.TColumn elem) {
       if (this.columns == null) {
         this.columns = new ArrayList<org.apache.accumulo.core.data.thrift.TColumn>();
       }
       this.columns.add(elem);
     }
 
     public List<org.apache.accumulo.core.data.thrift.TColumn> getColumns() {
       return this.columns;
     }
 
     public startScan_args setColumns(List<org.apache.accumulo.core.data.thrift.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 getBatchSize() {
       return this.batchSize;
     }
 
     public startScan_args setBatchSize(int batchSize) {
       this.batchSize = batchSize;
       setBatchSizeIsSet(true);
       return this;
     }
 
     public void unsetBatchSize() {
       __isset_bitfield = 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 EncodingUtils.testBit(__isset_bitfield, __BATCHSIZE_ISSET_ID);
     }
 
     public void setBatchSizeIsSet(boolean value) {
       __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __BATCHSIZE_ISSET_ID, value);
     }
 
     public int getSsiListSize() {
       return (this.ssiList == null) ? 0 : this.ssiList.size();
     }
 
     public java.util.Iterator<org.apache.accumulo.core.data.thrift.IterInfo> getSsiListIterator() {
       return (this.ssiList == null) ? null : this.ssiList.iterator();
     }
 
     public void addToSsiList(org.apache.accumulo.core.data.thrift.IterInfo elem) {
       if (this.ssiList == null) {
         this.ssiList = new ArrayList<org.apache.accumulo.core.data.thrift.IterInfo>();
       }
       this.ssiList.add(elem);
     }
 
     public List<org.apache.accumulo.core.data.thrift.IterInfo> getSsiList() {
       return this.ssiList;
     }
 
     public startScan_args setSsiList(List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList) {
       this.ssiList = ssiList;
       return this;
     }
 
     public void unsetSsiList() {
       this.ssiList = null;
     }
 
     /** Returns true if field ssiList is set (has been assigned a value) and false otherwise */
     public boolean isSetSsiList() {
       return this.ssiList != null;
     }
 
     public void setSsiListIsSet(boolean value) {
       if (!value) {
         this.ssiList = null;
       }
     }
 
     public int getSsioSize() {
       return (this.ssio == null) ? 0 : this.ssio.size();
     }
 
     public void putToSsio(String key, Map<String,String> val) {
       if (this.ssio == null) {
         this.ssio = new HashMap<String,Map<String,String>>();
       }
       this.ssio.put(key, val);
     }
 
     public Map<String,Map<String,String>> getSsio() {
       return this.ssio;
     }
 
     public startScan_args setSsio(Map<String,Map<String,String>> ssio) {
       this.ssio = ssio;
       return this;
     }
 
     public void unsetSsio() {
       this.ssio = null;
     }
 
     /** Returns true if field ssio is set (has been assigned a value) and false otherwise */
     public boolean isSetSsio() {
       return this.ssio != null;
     }
 
     public void setSsioIsSet(boolean value) {
       if (!value) {
         this.ssio = null;
       }
     }
 
     public int getAuthorizationsSize() {
       return (this.authorizations == null) ? 0 : this.authorizations.size();
     }
 
     public java.util.Iterator<ByteBuffer> getAuthorizationsIterator() {
       return (this.authorizations == null) ? null : this.authorizations.iterator();
     }
 
     public void addToAuthorizations(ByteBuffer elem) {
       if (this.authorizations == null) {
         this.authorizations = new ArrayList<ByteBuffer>();
       }
       this.authorizations.add(elem);
     }
 
     public List<ByteBuffer> getAuthorizations() {
       return this.authorizations;
     }
 
     public startScan_args setAuthorizations(List<ByteBuffer> 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 isWaitForWrites() {
       return this.waitForWrites;
     }
 
     public startScan_args setWaitForWrites(boolean waitForWrites) {
       this.waitForWrites = waitForWrites;
       setWaitForWritesIsSet(true);
       return this;
     }
 
     public void unsetWaitForWrites() {
       __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __WAITFORWRITES_ISSET_ID);
     }
 
     /** Returns true if field waitForWrites is set (has been assigned a value) and false otherwise */
     public boolean isSetWaitForWrites() {
       return EncodingUtils.testBit(__isset_bitfield, __WAITFORWRITES_ISSET_ID);
     }
 
     public void setWaitForWritesIsSet(boolean value) {
       __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __WAITFORWRITES_ISSET_ID, value);
     }
 
     public boolean isIsolated() {
       return this.isolated;
     }
 
     public startScan_args setIsolated(boolean isolated) {
       this.isolated = isolated;
       setIsolatedIsSet(true);
       return this;
     }
 
     public void unsetIsolated() {
       __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __ISOLATED_ISSET_ID);
     }
 
     /** Returns true if field isolated is set (has been assigned a value) and false otherwise */
     public boolean isSetIsolated() {
       return EncodingUtils.testBit(__isset_bitfield, __ISOLATED_ISSET_ID);
     }
 
     public void setIsolatedIsSet(boolean value) {
       __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ISOLATED_ISSET_ID, value);
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       case EXTENT:
         if (value == null) {
           unsetExtent();
         } else {
           setExtent((org.apache.accumulo.core.data.thrift.TKeyExtent)value);
         }
         break;
 
       case RANGE:
         if (value == null) {
           unsetRange();
         } else {
           setRange((org.apache.accumulo.core.data.thrift.TRange)value);
         }
         break;
 
       case COLUMNS:
         if (value == null) {
           unsetColumns();
         } else {
           setColumns((List<org.apache.accumulo.core.data.thrift.TColumn>)value);
         }
         break;
 
       case BATCH_SIZE:
         if (value == null) {
           unsetBatchSize();
         } else {
           setBatchSize((Integer)value);
         }
         break;
 
       case SSI_LIST:
         if (value == null) {
           unsetSsiList();
         } else {
           setSsiList((List<org.apache.accumulo.core.data.thrift.IterInfo>)value);
         }
         break;
 
       case SSIO:
         if (value == null) {
           unsetSsio();
         } else {
           setSsio((Map<String,Map<String,String>>)value);
         }
         break;
 
       case AUTHORIZATIONS:
         if (value == null) {
           unsetAuthorizations();
         } else {
           setAuthorizations((List<ByteBuffer>)value);
         }
         break;
 
       case WAIT_FOR_WRITES:
         if (value == null) {
           unsetWaitForWrites();
         } else {
           setWaitForWrites((Boolean)value);
         }
         break;
 
       case ISOLATED:
         if (value == null) {
           unsetIsolated();
         } else {
           setIsolated((Boolean)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       case EXTENT:
         return getExtent();
 
       case RANGE:
         return getRange();
 
       case COLUMNS:
         return getColumns();
 
       case BATCH_SIZE:
         return Integer.valueOf(getBatchSize());
 
       case SSI_LIST:
         return getSsiList();
 
       case SSIO:
         return getSsio();
 
       case AUTHORIZATIONS:
         return getAuthorizations();
 
       case WAIT_FOR_WRITES:
         return Boolean.valueOf(isWaitForWrites());
 
       case ISOLATED:
         return Boolean.valueOf(isIsolated());
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       case EXTENT:
         return isSetExtent();
       case RANGE:
         return isSetRange();
       case COLUMNS:
         return isSetColumns();
       case BATCH_SIZE:
         return isSetBatchSize();
       case SSI_LIST:
         return isSetSsiList();
       case SSIO:
         return isSetSsio();
       case AUTHORIZATIONS:
         return isSetAuthorizations();
       case WAIT_FOR_WRITES:
         return isSetWaitForWrites();
       case ISOLATED:
         return isSetIsolated();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof startScan_args)
         return this.equals((startScan_args)that);
       return false;
     }
 
     public boolean equals(startScan_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       boolean this_present_extent = true && this.isSetExtent();
       boolean that_present_extent = true && that.isSetExtent();
       if (this_present_extent || that_present_extent) {
         if (!(this_present_extent && that_present_extent))
           return false;
         if (!this.extent.equals(that.extent))
           return false;
       }
 
       boolean this_present_range = true && this.isSetRange();
       boolean that_present_range = true && that.isSetRange();
       if (this_present_range || that_present_range) {
         if (!(this_present_range && that_present_range))
           return false;
         if (!this.range.equals(that.range))
           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_batchSize = true;
       boolean that_present_batchSize = true;
       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_ssiList = true && this.isSetSsiList();
       boolean that_present_ssiList = true && that.isSetSsiList();
       if (this_present_ssiList || that_present_ssiList) {
         if (!(this_present_ssiList && that_present_ssiList))
           return false;
         if (!this.ssiList.equals(that.ssiList))
           return false;
       }
 
       boolean this_present_ssio = true && this.isSetSsio();
       boolean that_present_ssio = true && that.isSetSsio();
       if (this_present_ssio || that_present_ssio) {
         if (!(this_present_ssio && that_present_ssio))
           return false;
         if (!this.ssio.equals(that.ssio))
           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_waitForWrites = true;
       boolean that_present_waitForWrites = true;
       if (this_present_waitForWrites || that_present_waitForWrites) {
         if (!(this_present_waitForWrites && that_present_waitForWrites))
           return false;
         if (this.waitForWrites != that.waitForWrites)
           return false;
       }
 
       boolean this_present_isolated = true;
       boolean that_present_isolated = true;
       if (this_present_isolated || that_present_isolated) {
         if (!(this_present_isolated && that_present_isolated))
           return false;
         if (this.isolated != that.isolated)
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(startScan_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       startScan_args typedOther = (startScan_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetExtent()).compareTo(typedOther.isSetExtent());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetExtent()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extent, typedOther.extent);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetRange()).compareTo(typedOther.isSetRange());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetRange()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.range, typedOther.range);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetColumns()).compareTo(typedOther.isSetColumns());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetColumns()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetBatchSize()).compareTo(typedOther.isSetBatchSize());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetBatchSize()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.batchSize, typedOther.batchSize);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetSsiList()).compareTo(typedOther.isSetSsiList());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSsiList()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ssiList, typedOther.ssiList);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetSsio()).compareTo(typedOther.isSetSsio());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSsio()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ssio, typedOther.ssio);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetAuthorizations()).compareTo(typedOther.isSetAuthorizations());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetAuthorizations()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authorizations, typedOther.authorizations);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetWaitForWrites()).compareTo(typedOther.isSetWaitForWrites());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetWaitForWrites()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.waitForWrites, typedOther.waitForWrites);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetIsolated()).compareTo(typedOther.isSetIsolated());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetIsolated()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.isolated, typedOther.isolated);
         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("startScan_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("extent:");
       if (this.extent == null) {
         sb.append("null");
       } else {
         sb.append(this.extent);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("range:");
       if (this.range == null) {
         sb.append("null");
       } else {
         sb.append(this.range);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("columns:");
       if (this.columns == null) {
         sb.append("null");
       } else {
         sb.append(this.columns);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("batchSize:");
       sb.append(this.batchSize);
       first = false;
       if (!first) sb.append(", ");
       sb.append("ssiList:");
       if (this.ssiList == null) {
         sb.append("null");
       } else {
         sb.append(this.ssiList);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("ssio:");
       if (this.ssio == null) {
         sb.append("null");
       } else {
         sb.append(this.ssio);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("authorizations:");
       if (this.authorizations == null) {
         sb.append("null");
       } else {
         sb.append(this.authorizations);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("waitForWrites:");
       sb.append(this.waitForWrites);
       first = false;
       if (!first) sb.append(", ");
       sb.append("isolated:");
       sb.append(this.isolated);
       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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.validate();
       }
       if (extent != null) {
         extent.validate();
       }
       if (range != null) {
         range.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, 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 startScan_argsStandardSchemeFactory implements SchemeFactory {
       public startScan_argsStandardScheme getScheme() {
         return new startScan_argsStandardScheme();
       }
     }
 
     private static class startScan_argsStandardScheme extends StandardScheme<startScan_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, startScan_args 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 11: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // EXTENT
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.extent = new org.apache.accumulo.core.data.thrift.TKeyExtent();
                 struct.extent.read(iprot);
                 struct.setExtentIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 3: // RANGE
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.range = new org.apache.accumulo.core.data.thrift.TRange();
                 struct.range.read(iprot);
                 struct.setRangeIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 4: // COLUMNS
               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                 {
                   org.apache.thrift.protocol.TList _list106 = iprot.readListBegin();
                   struct.columns = new ArrayList<org.apache.accumulo.core.data.thrift.TColumn>(_list106.size);
                   for (int _i107 = 0; _i107 < _list106.size; ++_i107)
                   {
                     org.apache.accumulo.core.data.thrift.TColumn _elem108; // required
                     _elem108 = new org.apache.accumulo.core.data.thrift.TColumn();
                     _elem108.read(iprot);
                     struct.columns.add(_elem108);
                   }
                   iprot.readListEnd();
                 }
                 struct.setColumnsIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 5: // 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 6: // SSI_LIST
               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                 {
                   org.apache.thrift.protocol.TList _list109 = iprot.readListBegin();
                   struct.ssiList = new ArrayList<org.apache.accumulo.core.data.thrift.IterInfo>(_list109.size);
                   for (int _i110 = 0; _i110 < _list109.size; ++_i110)
                   {
                     org.apache.accumulo.core.data.thrift.IterInfo _elem111; // required
                     _elem111 = new org.apache.accumulo.core.data.thrift.IterInfo();
                     _elem111.read(iprot);
                     struct.ssiList.add(_elem111);
                   }
                   iprot.readListEnd();
                 }
                 struct.setSsiListIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 7: // SSIO
               if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
                 {
                   org.apache.thrift.protocol.TMap _map112 = iprot.readMapBegin();
                   struct.ssio = new HashMap<String,Map<String,String>>(2*_map112.size);
                   for (int _i113 = 0; _i113 < _map112.size; ++_i113)
                   {
                     String _key114; // required
                     Map<String,String> _val115; // required
                     _key114 = iprot.readString();
                     {
                       org.apache.thrift.protocol.TMap _map116 = iprot.readMapBegin();
                       _val115 = new HashMap<String,String>(2*_map116.size);
                       for (int _i117 = 0; _i117 < _map116.size; ++_i117)
                       {
                         String _key118; // required
                         String _val119; // required
                         _key118 = iprot.readString();
                         _val119 = iprot.readString();
                         _val115.put(_key118, _val119);
                       }
                       iprot.readMapEnd();
                     }
                     struct.ssio.put(_key114, _val115);
                   }
                   iprot.readMapEnd();
                 }
                 struct.setSsioIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 8: // AUTHORIZATIONS
               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                 {
                   org.apache.thrift.protocol.TList _list120 = iprot.readListBegin();
                   struct.authorizations = new ArrayList<ByteBuffer>(_list120.size);
                   for (int _i121 = 0; _i121 < _list120.size; ++_i121)
                   {
                     ByteBuffer _elem122; // required
                     _elem122 = iprot.readBinary();
                     struct.authorizations.add(_elem122);
                   }
                   iprot.readListEnd();
                 }
                 struct.setAuthorizationsIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 9: // WAIT_FOR_WRITES
               if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
                 struct.waitForWrites = iprot.readBool();
                 struct.setWaitForWritesIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 10: // ISOLATED
               if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
                 struct.isolated = iprot.readBool();
                 struct.setIsolatedIsSet(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, startScan_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.extent != null) {
           oprot.writeFieldBegin(EXTENT_FIELD_DESC);
           struct.extent.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.range != null) {
           oprot.writeFieldBegin(RANGE_FIELD_DESC);
           struct.range.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.columns != null) {
           oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.columns.size()));
             for (org.apache.accumulo.core.data.thrift.TColumn _iter123 : struct.columns)
             {
               _iter123.write(oprot);
             }
             oprot.writeListEnd();
           }
           oprot.writeFieldEnd();
         }
         oprot.writeFieldBegin(BATCH_SIZE_FIELD_DESC);
         oprot.writeI32(struct.batchSize);
         oprot.writeFieldEnd();
         if (struct.ssiList != null) {
           oprot.writeFieldBegin(SSI_LIST_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.ssiList.size()));
             for (org.apache.accumulo.core.data.thrift.IterInfo _iter124 : struct.ssiList)
             {
               _iter124.write(oprot);
             }
             oprot.writeListEnd();
           }
           oprot.writeFieldEnd();
         }
         if (struct.ssio != null) {
           oprot.writeFieldBegin(SSIO_FIELD_DESC);
           {
             oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.MAP, struct.ssio.size()));
             for (Map.Entry<String, Map<String,String>> _iter125 : struct.ssio.entrySet())
             {
               oprot.writeString(_iter125.getKey());
               {
                 oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter125.getValue().size()));
                 for (Map.Entry<String, String> _iter126 : _iter125.getValue().entrySet())
                 {
                   oprot.writeString(_iter126.getKey());
                   oprot.writeString(_iter126.getValue());
                 }
                 oprot.writeMapEnd();
               }
             }
             oprot.writeMapEnd();
           }
           oprot.writeFieldEnd();
         }
         if (struct.authorizations != null) {
           oprot.writeFieldBegin(AUTHORIZATIONS_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.authorizations.size()));
             for (ByteBuffer _iter127 : struct.authorizations)
             {
               oprot.writeBinary(_iter127);
             }
             oprot.writeListEnd();
           }
           oprot.writeFieldEnd();
         }
         oprot.writeFieldBegin(WAIT_FOR_WRITES_FIELD_DESC);
         oprot.writeBool(struct.waitForWrites);
         oprot.writeFieldEnd();
         oprot.writeFieldBegin(ISOLATED_FIELD_DESC);
         oprot.writeBool(struct.isolated);
         oprot.writeFieldEnd();
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class startScan_argsTupleSchemeFactory implements SchemeFactory {
       public startScan_argsTupleScheme getScheme() {
         return new startScan_argsTupleScheme();
       }
     }
 
     private static class startScan_argsTupleScheme extends TupleScheme<startScan_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, startScan_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         if (struct.isSetExtent()) {
           optionals.set(2);
         }
         if (struct.isSetRange()) {
           optionals.set(3);
         }
         if (struct.isSetColumns()) {
           optionals.set(4);
         }
         if (struct.isSetBatchSize()) {
           optionals.set(5);
         }
         if (struct.isSetSsiList()) {
           optionals.set(6);
         }
         if (struct.isSetSsio()) {
           optionals.set(7);
         }
         if (struct.isSetAuthorizations()) {
           optionals.set(8);
         }
         if (struct.isSetWaitForWrites()) {
           optionals.set(9);
         }
         if (struct.isSetIsolated()) {
           optionals.set(10);
         }
         oprot.writeBitSet(optionals, 11);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
         if (struct.isSetExtent()) {
           struct.extent.write(oprot);
         }
         if (struct.isSetRange()) {
           struct.range.write(oprot);
         }
         if (struct.isSetColumns()) {
           {
             oprot.writeI32(struct.columns.size());
             for (org.apache.accumulo.core.data.thrift.TColumn _iter128 : struct.columns)
             {
               _iter128.write(oprot);
             }
           }
         }
         if (struct.isSetBatchSize()) {
           oprot.writeI32(struct.batchSize);
         }
         if (struct.isSetSsiList()) {
           {
             oprot.writeI32(struct.ssiList.size());
             for (org.apache.accumulo.core.data.thrift.IterInfo _iter129 : struct.ssiList)
             {
               _iter129.write(oprot);
             }
           }
         }
         if (struct.isSetSsio()) {
           {
             oprot.writeI32(struct.ssio.size());
             for (Map.Entry<String, Map<String,String>> _iter130 : struct.ssio.entrySet())
             {
               oprot.writeString(_iter130.getKey());
               {
                 oprot.writeI32(_iter130.getValue().size());
                 for (Map.Entry<String, String> _iter131 : _iter130.getValue().entrySet())
                 {
                   oprot.writeString(_iter131.getKey());
                   oprot.writeString(_iter131.getValue());
                 }
               }
             }
           }
         }
         if (struct.isSetAuthorizations()) {
           {
             oprot.writeI32(struct.authorizations.size());
             for (ByteBuffer _iter132 : struct.authorizations)
             {
               oprot.writeBinary(_iter132);
             }
           }
         }
         if (struct.isSetWaitForWrites()) {
           oprot.writeBool(struct.waitForWrites);
         }
         if (struct.isSetIsolated()) {
           oprot.writeBool(struct.isolated);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, startScan_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(11);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
         if (incoming.get(2)) {
           struct.extent = new org.apache.accumulo.core.data.thrift.TKeyExtent();
           struct.extent.read(iprot);
           struct.setExtentIsSet(true);
         }
         if (incoming.get(3)) {
           struct.range = new org.apache.accumulo.core.data.thrift.TRange();
           struct.range.read(iprot);
           struct.setRangeIsSet(true);
         }
         if (incoming.get(4)) {
           {
             org.apache.thrift.protocol.TList _list133 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
             struct.columns = new ArrayList<org.apache.accumulo.core.data.thrift.TColumn>(_list133.size);
             for (int _i134 = 0; _i134 < _list133.size; ++_i134)
             {
               org.apache.accumulo.core.data.thrift.TColumn _elem135; // required
               _elem135 = new org.apache.accumulo.core.data.thrift.TColumn();
               _elem135.read(iprot);
               struct.columns.add(_elem135);
             }
           }
           struct.setColumnsIsSet(true);
         }
         if (incoming.get(5)) {
           struct.batchSize = iprot.readI32();
           struct.setBatchSizeIsSet(true);
         }
         if (incoming.get(6)) {
           {
             org.apache.thrift.protocol.TList _list136 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
             struct.ssiList = new ArrayList<org.apache.accumulo.core.data.thrift.IterInfo>(_list136.size);
             for (int _i137 = 0; _i137 < _list136.size; ++_i137)
             {
               org.apache.accumulo.core.data.thrift.IterInfo _elem138; // required
               _elem138 = new org.apache.accumulo.core.data.thrift.IterInfo();
               _elem138.read(iprot);
               struct.ssiList.add(_elem138);
             }
           }
           struct.setSsiListIsSet(true);
         }
         if (incoming.get(7)) {
           {
             org.apache.thrift.protocol.TMap _map139 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.MAP, iprot.readI32());
             struct.ssio = new HashMap<String,Map<String,String>>(2*_map139.size);
             for (int _i140 = 0; _i140 < _map139.size; ++_i140)
             {
               String _key141; // required
               Map<String,String> _val142; // required
               _key141 = iprot.readString();
               {
                 org.apache.thrift.protocol.TMap _map143 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32());
                 _val142 = new HashMap<String,String>(2*_map143.size);
                 for (int _i144 = 0; _i144 < _map143.size; ++_i144)
                 {
                   String _key145; // required
                   String _val146; // required
                   _key145 = iprot.readString();
                   _val146 = iprot.readString();
                   _val142.put(_key145, _val146);
                 }
               }
               struct.ssio.put(_key141, _val142);
             }
           }
           struct.setSsioIsSet(true);
         }
         if (incoming.get(8)) {
           {
             org.apache.thrift.protocol.TList _list147 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
             struct.authorizations = new ArrayList<ByteBuffer>(_list147.size);
             for (int _i148 = 0; _i148 < _list147.size; ++_i148)
             {
               ByteBuffer _elem149; // required
               _elem149 = iprot.readBinary();
               struct.authorizations.add(_elem149);
             }
           }
           struct.setAuthorizationsIsSet(true);
         }
         if (incoming.get(9)) {
           struct.waitForWrites = iprot.readBool();
           struct.setWaitForWritesIsSet(true);
         }
         if (incoming.get(10)) {
           struct.isolated = iprot.readBool();
           struct.setIsolatedIsSet(true);
         }
       }
     }
 
   }
 
   public static class startScan_result implements org.apache.thrift.TBase<startScan_result, startScan_result._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("startScan_result");
 
     private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
     private static final org.apache.thrift.protocol.TField SEC_FIELD_DESC = new org.apache.thrift.protocol.TField("sec", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField NSTE_FIELD_DESC = new org.apache.thrift.protocol.TField("nste", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField TMFE_FIELD_DESC = new org.apache.thrift.protocol.TField("tmfe", org.apache.thrift.protocol.TType.STRUCT, (short)3);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new startScan_resultStandardSchemeFactory());
       schemes.put(TupleScheme.class, new startScan_resultTupleSchemeFactory());
     }
 
     public org.apache.accumulo.core.data.thrift.InitialScan success; // required
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException sec; // required
     public NotServingTabletException nste; // required
     public TooManyFilesException tmfe; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       SUCCESS((short)0, "success"),
       SEC((short)1, "sec"),
       NSTE((short)2, "nste"),
       TMFE((short)3, "tmfe");
 
       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 0: // SUCCESS
             return SUCCESS;
           case 1: // SEC
             return SEC;
           case 2: // NSTE
             return NSTE;
           case 3: // TMFE
             return TMFE;
           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
     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.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.data.thrift.InitialScan.class)));
       tmpMap.put(_Fields.SEC, new org.apache.thrift.meta_data.FieldMetaData("sec", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       tmpMap.put(_Fields.NSTE, new org.apache.thrift.meta_data.FieldMetaData("nste", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       tmpMap.put(_Fields.TMFE, new org.apache.thrift.meta_data.FieldMetaData("tmfe", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(startScan_result.class, metaDataMap);
     }
 
     public startScan_result() {
     }
 
     public startScan_result(
       org.apache.accumulo.core.data.thrift.InitialScan success,
       org.apache.accumulo.core.security.thrift.ThriftSecurityException sec,
       NotServingTabletException nste,
       TooManyFilesException tmfe)
     {
       this();
       this.success = success;
       this.sec = sec;
       this.nste = nste;
       this.tmfe = tmfe;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public startScan_result(startScan_result other) {
       if (other.isSetSuccess()) {
         this.success = new org.apache.accumulo.core.data.thrift.InitialScan(other.success);
       }
       if (other.isSetSec()) {
         this.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException(other.sec);
       }
       if (other.isSetNste()) {
         this.nste = new NotServingTabletException(other.nste);
       }
       if (other.isSetTmfe()) {
         this.tmfe = new TooManyFilesException(other.tmfe);
       }
     }
 
     public startScan_result deepCopy() {
       return new startScan_result(this);
     }
 
     @Override
     public void clear() {
       this.success = null;
       this.sec = null;
       this.nste = null;
       this.tmfe = null;
     }
 
     public org.apache.accumulo.core.data.thrift.InitialScan getSuccess() {
       return this.success;
     }
 
     public startScan_result setSuccess(org.apache.accumulo.core.data.thrift.InitialScan success) {
       this.success = success;
       return this;
     }
 
     public void unsetSuccess() {
       this.success = null;
     }
 
     /** Returns true if field success is set (has been assigned a value) and false otherwise */
     public boolean isSetSuccess() {
       return this.success != null;
     }
 
     public void setSuccessIsSet(boolean value) {
       if (!value) {
         this.success = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException getSec() {
       return this.sec;
     }
 
     public startScan_result setSec(org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
       this.sec = sec;
       return this;
     }
 
     public void unsetSec() {
       this.sec = null;
     }
 
     /** Returns true if field sec is set (has been assigned a value) and false otherwise */
     public boolean isSetSec() {
       return this.sec != null;
     }
 
     public void setSecIsSet(boolean value) {
       if (!value) {
         this.sec = null;
       }
     }
 
     public NotServingTabletException getNste() {
       return this.nste;
     }
 
     public startScan_result setNste(NotServingTabletException nste) {
       this.nste = nste;
       return this;
     }
 
     public void unsetNste() {
       this.nste = null;
     }
 
     /** Returns true if field nste is set (has been assigned a value) and false otherwise */
     public boolean isSetNste() {
       return this.nste != null;
     }
 
     public void setNsteIsSet(boolean value) {
       if (!value) {
         this.nste = null;
       }
     }
 
     public TooManyFilesException getTmfe() {
       return this.tmfe;
     }
 
     public startScan_result setTmfe(TooManyFilesException tmfe) {
       this.tmfe = tmfe;
       return this;
     }
 
     public void unsetTmfe() {
       this.tmfe = null;
     }
 
     /** Returns true if field tmfe is set (has been assigned a value) and false otherwise */
     public boolean isSetTmfe() {
       return this.tmfe != null;
     }
 
     public void setTmfeIsSet(boolean value) {
       if (!value) {
         this.tmfe = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
           setSuccess((org.apache.accumulo.core.data.thrift.InitialScan)value);
         }
         break;
 
       case SEC:
         if (value == null) {
           unsetSec();
         } else {
           setSec((org.apache.accumulo.core.security.thrift.ThriftSecurityException)value);
         }
         break;
 
       case NSTE:
         if (value == null) {
           unsetNste();
         } else {
           setNste((NotServingTabletException)value);
         }
         break;
 
       case TMFE:
         if (value == null) {
           unsetTmfe();
         } else {
           setTmfe((TooManyFilesException)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
         return getSuccess();
 
       case SEC:
         return getSec();
 
       case NSTE:
         return getNste();
 
       case TMFE:
         return getTmfe();
 
       }
       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 SUCCESS:
         return isSetSuccess();
       case SEC:
         return isSetSec();
       case NSTE:
         return isSetNste();
       case TMFE:
         return isSetTmfe();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof startScan_result)
         return this.equals((startScan_result)that);
       return false;
     }
 
     public boolean equals(startScan_result that) {
       if (that == null)
         return false;
 
       boolean this_present_success = true && this.isSetSuccess();
       boolean that_present_success = true && that.isSetSuccess();
       if (this_present_success || that_present_success) {
         if (!(this_present_success && that_present_success))
           return false;
         if (!this.success.equals(that.success))
           return false;
       }
 
       boolean this_present_sec = true && this.isSetSec();
       boolean that_present_sec = true && that.isSetSec();
       if (this_present_sec || that_present_sec) {
         if (!(this_present_sec && that_present_sec))
           return false;
         if (!this.sec.equals(that.sec))
           return false;
       }
 
       boolean this_present_nste = true && this.isSetNste();
       boolean that_present_nste = true && that.isSetNste();
       if (this_present_nste || that_present_nste) {
         if (!(this_present_nste && that_present_nste))
           return false;
         if (!this.nste.equals(that.nste))
           return false;
       }
 
       boolean this_present_tmfe = true && this.isSetTmfe();
       boolean that_present_tmfe = true && that.isSetTmfe();
       if (this_present_tmfe || that_present_tmfe) {
         if (!(this_present_tmfe && that_present_tmfe))
           return false;
         if (!this.tmfe.equals(that.tmfe))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(startScan_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       startScan_result typedOther = (startScan_result)other;
 
       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSuccess()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetSec()).compareTo(typedOther.isSetSec());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSec()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sec, typedOther.sec);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetNste()).compareTo(typedOther.isSetNste());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetNste()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nste, typedOther.nste);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetTmfe()).compareTo(typedOther.isSetTmfe());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTmfe()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tmfe, typedOther.tmfe);
         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("startScan_result(");
       boolean first = true;
 
       sb.append("success:");
       if (this.success == null) {
         sb.append("null");
       } else {
         sb.append(this.success);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("sec:");
       if (this.sec == null) {
         sb.append("null");
       } else {
         sb.append(this.sec);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("nste:");
       if (this.nste == null) {
         sb.append("null");
       } else {
         sb.append(this.nste);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("tmfe:");
       if (this.tmfe == null) {
         sb.append("null");
       } else {
         sb.append(this.tmfe);
       }
       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 (success != null) {
         success.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, ClassNotFoundException {
       try {
         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 startScan_resultStandardSchemeFactory implements SchemeFactory {
       public startScan_resultStandardScheme getScheme() {
         return new startScan_resultStandardScheme();
       }
     }
 
     private static class startScan_resultStandardScheme extends StandardScheme<startScan_result> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, startScan_result 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 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.success = new org.apache.accumulo.core.data.thrift.InitialScan();
                 struct.success.read(iprot);
                 struct.setSuccessIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // SEC
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
                 struct.sec.read(iprot);
                 struct.setSecIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // NSTE
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.nste = new NotServingTabletException();
                 struct.nste.read(iprot);
                 struct.setNsteIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 3: // TMFE
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tmfe = new TooManyFilesException();
                 struct.tmfe.read(iprot);
                 struct.setTmfeIsSet(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, startScan_result struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.success != null) {
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           struct.success.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.sec != null) {
           oprot.writeFieldBegin(SEC_FIELD_DESC);
           struct.sec.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.nste != null) {
           oprot.writeFieldBegin(NSTE_FIELD_DESC);
           struct.nste.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.tmfe != null) {
           oprot.writeFieldBegin(TMFE_FIELD_DESC);
           struct.tmfe.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class startScan_resultTupleSchemeFactory implements SchemeFactory {
       public startScan_resultTupleScheme getScheme() {
         return new startScan_resultTupleScheme();
       }
     }
 
     private static class startScan_resultTupleScheme extends TupleScheme<startScan_result> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, startScan_result struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetSuccess()) {
           optionals.set(0);
         }
         if (struct.isSetSec()) {
           optionals.set(1);
         }
         if (struct.isSetNste()) {
           optionals.set(2);
         }
         if (struct.isSetTmfe()) {
           optionals.set(3);
         }
         oprot.writeBitSet(optionals, 4);
         if (struct.isSetSuccess()) {
           struct.success.write(oprot);
         }
         if (struct.isSetSec()) {
           struct.sec.write(oprot);
         }
         if (struct.isSetNste()) {
           struct.nste.write(oprot);
         }
         if (struct.isSetTmfe()) {
           struct.tmfe.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, startScan_result struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(4);
         if (incoming.get(0)) {
           struct.success = new org.apache.accumulo.core.data.thrift.InitialScan();
           struct.success.read(iprot);
           struct.setSuccessIsSet(true);
         }
         if (incoming.get(1)) {
           struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
           struct.sec.read(iprot);
           struct.setSecIsSet(true);
         }
         if (incoming.get(2)) {
           struct.nste = new NotServingTabletException();
           struct.nste.read(iprot);
           struct.setNsteIsSet(true);
         }
         if (incoming.get(3)) {
           struct.tmfe = new TooManyFilesException();
           struct.tmfe.read(iprot);
           struct.setTmfeIsSet(true);
         }
       }
     }
 
   }
 
   public static class continueScan_args implements org.apache.thrift.TBase<continueScan_args, continueScan_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("continueScan_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField SCAN_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("scanID", org.apache.thrift.protocol.TType.I64, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new continueScan_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new continueScan_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public long scanID; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)2, "tinfo"),
       SCAN_ID((short)1, "scanID");
 
       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 2: // TINFO
             return TINFO;
           case 1: // SCAN_ID
             return SCAN_ID;
           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 __SCANID_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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.SCAN_ID, new org.apache.thrift.meta_data.FieldMetaData("scanID", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64          , "ScanID")));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(continueScan_args.class, metaDataMap);
     }
 
     public continueScan_args() {
     }
 
     public continueScan_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       long scanID)
     {
       this();
       this.tinfo = tinfo;
       this.scanID = scanID;
       setScanIDIsSet(true);
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public continueScan_args(continueScan_args other) {
       __isset_bitfield = other.__isset_bitfield;
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       this.scanID = other.scanID;
     }
 
     public continueScan_args deepCopy() {
       return new continueScan_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       setScanIDIsSet(false);
       this.scanID = 0;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public continueScan_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public long getScanID() {
       return this.scanID;
     }
 
     public continueScan_args setScanID(long scanID) {
       this.scanID = scanID;
       setScanIDIsSet(true);
       return this;
     }
 
     public void unsetScanID() {
       __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SCANID_ISSET_ID);
     }
 
     /** Returns true if field scanID is set (has been assigned a value) and false otherwise */
     public boolean isSetScanID() {
       return EncodingUtils.testBit(__isset_bitfield, __SCANID_ISSET_ID);
     }
 
     public void setScanIDIsSet(boolean value) {
       __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SCANID_ISSET_ID, value);
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case SCAN_ID:
         if (value == null) {
           unsetScanID();
         } else {
           setScanID((Long)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case SCAN_ID:
         return Long.valueOf(getScanID());
 
       }
       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 TINFO:
         return isSetTinfo();
       case SCAN_ID:
         return isSetScanID();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof continueScan_args)
         return this.equals((continueScan_args)that);
       return false;
     }
 
     public boolean equals(continueScan_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_scanID = true;
       boolean that_present_scanID = true;
       if (this_present_scanID || that_present_scanID) {
         if (!(this_present_scanID && that_present_scanID))
           return false;
         if (this.scanID != that.scanID)
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(continueScan_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       continueScan_args typedOther = (continueScan_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetScanID()).compareTo(typedOther.isSetScanID());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetScanID()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scanID, typedOther.scanID);
         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("continueScan_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("scanID:");
       sb.append(this.scanID);
       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 (tinfo != null) {
         tinfo.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, 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 continueScan_argsStandardSchemeFactory implements SchemeFactory {
       public continueScan_argsStandardScheme getScheme() {
         return new continueScan_argsStandardScheme();
       }
     }
 
     private static class continueScan_argsStandardScheme extends StandardScheme<continueScan_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, continueScan_args 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 2: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // SCAN_ID
               if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
                 struct.scanID = iprot.readI64();
                 struct.setScanIDIsSet(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, continueScan_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         oprot.writeFieldBegin(SCAN_ID_FIELD_DESC);
         oprot.writeI64(struct.scanID);
         oprot.writeFieldEnd();
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class continueScan_argsTupleSchemeFactory implements SchemeFactory {
       public continueScan_argsTupleScheme getScheme() {
         return new continueScan_argsTupleScheme();
       }
     }
 
     private static class continueScan_argsTupleScheme extends TupleScheme<continueScan_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, continueScan_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetScanID()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetScanID()) {
           oprot.writeI64(struct.scanID);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, continueScan_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.scanID = iprot.readI64();
           struct.setScanIDIsSet(true);
         }
       }
     }
 
   }
 
   public static class continueScan_result implements org.apache.thrift.TBase<continueScan_result, continueScan_result._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("continueScan_result");
 
     private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
     private static final org.apache.thrift.protocol.TField NSSI_FIELD_DESC = new org.apache.thrift.protocol.TField("nssi", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField NSTE_FIELD_DESC = new org.apache.thrift.protocol.TField("nste", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField TMFE_FIELD_DESC = new org.apache.thrift.protocol.TField("tmfe", org.apache.thrift.protocol.TType.STRUCT, (short)3);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new continueScan_resultStandardSchemeFactory());
       schemes.put(TupleScheme.class, new continueScan_resultTupleSchemeFactory());
     }
 
     public org.apache.accumulo.core.data.thrift.ScanResult success; // required
     public NoSuchScanIDException nssi; // required
     public NotServingTabletException nste; // required
     public TooManyFilesException tmfe; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       SUCCESS((short)0, "success"),
       NSSI((short)1, "nssi"),
       NSTE((short)2, "nste"),
       TMFE((short)3, "tmfe");
 
       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 0: // SUCCESS
             return SUCCESS;
           case 1: // NSSI
             return NSSI;
           case 2: // NSTE
             return NSTE;
           case 3: // TMFE
             return TMFE;
           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
     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.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.data.thrift.ScanResult.class)));
       tmpMap.put(_Fields.NSSI, new org.apache.thrift.meta_data.FieldMetaData("nssi", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       tmpMap.put(_Fields.NSTE, new org.apache.thrift.meta_data.FieldMetaData("nste", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       tmpMap.put(_Fields.TMFE, new org.apache.thrift.meta_data.FieldMetaData("tmfe", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(continueScan_result.class, metaDataMap);
     }
 
     public continueScan_result() {
     }
 
     public continueScan_result(
       org.apache.accumulo.core.data.thrift.ScanResult success,
       NoSuchScanIDException nssi,
       NotServingTabletException nste,
       TooManyFilesException tmfe)
     {
       this();
       this.success = success;
       this.nssi = nssi;
       this.nste = nste;
       this.tmfe = tmfe;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public continueScan_result(continueScan_result other) {
       if (other.isSetSuccess()) {
         this.success = new org.apache.accumulo.core.data.thrift.ScanResult(other.success);
       }
       if (other.isSetNssi()) {
         this.nssi = new NoSuchScanIDException(other.nssi);
       }
       if (other.isSetNste()) {
         this.nste = new NotServingTabletException(other.nste);
       }
       if (other.isSetTmfe()) {
         this.tmfe = new TooManyFilesException(other.tmfe);
       }
     }
 
     public continueScan_result deepCopy() {
       return new continueScan_result(this);
     }
 
     @Override
     public void clear() {
       this.success = null;
       this.nssi = null;
       this.nste = null;
       this.tmfe = null;
     }
 
     public org.apache.accumulo.core.data.thrift.ScanResult getSuccess() {
       return this.success;
     }
 
     public continueScan_result setSuccess(org.apache.accumulo.core.data.thrift.ScanResult success) {
       this.success = success;
       return this;
     }
 
     public void unsetSuccess() {
       this.success = null;
     }
 
     /** Returns true if field success is set (has been assigned a value) and false otherwise */
     public boolean isSetSuccess() {
       return this.success != null;
     }
 
     public void setSuccessIsSet(boolean value) {
       if (!value) {
         this.success = null;
       }
     }
 
     public NoSuchScanIDException getNssi() {
       return this.nssi;
     }
 
     public continueScan_result setNssi(NoSuchScanIDException nssi) {
       this.nssi = nssi;
       return this;
     }
 
     public void unsetNssi() {
       this.nssi = null;
     }
 
     /** Returns true if field nssi is set (has been assigned a value) and false otherwise */
     public boolean isSetNssi() {
       return this.nssi != null;
     }
 
     public void setNssiIsSet(boolean value) {
       if (!value) {
         this.nssi = null;
       }
     }
 
     public NotServingTabletException getNste() {
       return this.nste;
     }
 
     public continueScan_result setNste(NotServingTabletException nste) {
       this.nste = nste;
       return this;
     }
 
     public void unsetNste() {
       this.nste = null;
     }
 
     /** Returns true if field nste is set (has been assigned a value) and false otherwise */
     public boolean isSetNste() {
       return this.nste != null;
     }
 
     public void setNsteIsSet(boolean value) {
       if (!value) {
         this.nste = null;
       }
     }
 
     public TooManyFilesException getTmfe() {
       return this.tmfe;
     }
 
     public continueScan_result setTmfe(TooManyFilesException tmfe) {
       this.tmfe = tmfe;
       return this;
     }
 
     public void unsetTmfe() {
       this.tmfe = null;
     }
 
     /** Returns true if field tmfe is set (has been assigned a value) and false otherwise */
     public boolean isSetTmfe() {
       return this.tmfe != null;
     }
 
     public void setTmfeIsSet(boolean value) {
       if (!value) {
         this.tmfe = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
           setSuccess((org.apache.accumulo.core.data.thrift.ScanResult)value);
         }
         break;
 
       case NSSI:
         if (value == null) {
           unsetNssi();
         } else {
           setNssi((NoSuchScanIDException)value);
         }
         break;
 
       case NSTE:
         if (value == null) {
           unsetNste();
         } else {
           setNste((NotServingTabletException)value);
         }
         break;
 
       case TMFE:
         if (value == null) {
           unsetTmfe();
         } else {
           setTmfe((TooManyFilesException)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
         return getSuccess();
 
       case NSSI:
         return getNssi();
 
       case NSTE:
         return getNste();
 
       case TMFE:
         return getTmfe();
 
       }
       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 SUCCESS:
         return isSetSuccess();
       case NSSI:
         return isSetNssi();
       case NSTE:
         return isSetNste();
       case TMFE:
         return isSetTmfe();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof continueScan_result)
         return this.equals((continueScan_result)that);
       return false;
     }
 
     public boolean equals(continueScan_result that) {
       if (that == null)
         return false;
 
       boolean this_present_success = true && this.isSetSuccess();
       boolean that_present_success = true && that.isSetSuccess();
       if (this_present_success || that_present_success) {
         if (!(this_present_success && that_present_success))
           return false;
         if (!this.success.equals(that.success))
           return false;
       }
 
       boolean this_present_nssi = true && this.isSetNssi();
       boolean that_present_nssi = true && that.isSetNssi();
       if (this_present_nssi || that_present_nssi) {
         if (!(this_present_nssi && that_present_nssi))
           return false;
         if (!this.nssi.equals(that.nssi))
           return false;
       }
 
       boolean this_present_nste = true && this.isSetNste();
       boolean that_present_nste = true && that.isSetNste();
       if (this_present_nste || that_present_nste) {
         if (!(this_present_nste && that_present_nste))
           return false;
         if (!this.nste.equals(that.nste))
           return false;
       }
 
       boolean this_present_tmfe = true && this.isSetTmfe();
       boolean that_present_tmfe = true && that.isSetTmfe();
       if (this_present_tmfe || that_present_tmfe) {
         if (!(this_present_tmfe && that_present_tmfe))
           return false;
         if (!this.tmfe.equals(that.tmfe))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(continueScan_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       continueScan_result typedOther = (continueScan_result)other;
 
       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSuccess()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetNssi()).compareTo(typedOther.isSetNssi());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetNssi()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nssi, typedOther.nssi);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetNste()).compareTo(typedOther.isSetNste());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetNste()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nste, typedOther.nste);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetTmfe()).compareTo(typedOther.isSetTmfe());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTmfe()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tmfe, typedOther.tmfe);
         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("continueScan_result(");
       boolean first = true;
 
       sb.append("success:");
       if (this.success == null) {
         sb.append("null");
       } else {
         sb.append(this.success);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("nssi:");
       if (this.nssi == null) {
         sb.append("null");
       } else {
         sb.append(this.nssi);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("nste:");
       if (this.nste == null) {
         sb.append("null");
       } else {
         sb.append(this.nste);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("tmfe:");
       if (this.tmfe == null) {
         sb.append("null");
       } else {
         sb.append(this.tmfe);
       }
       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 (success != null) {
         success.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, ClassNotFoundException {
       try {
         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 continueScan_resultStandardSchemeFactory implements SchemeFactory {
       public continueScan_resultStandardScheme getScheme() {
         return new continueScan_resultStandardScheme();
       }
     }
 
     private static class continueScan_resultStandardScheme extends StandardScheme<continueScan_result> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, continueScan_result 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 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.success = new org.apache.accumulo.core.data.thrift.ScanResult();
                 struct.success.read(iprot);
                 struct.setSuccessIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // NSSI
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.nssi = new NoSuchScanIDException();
                 struct.nssi.read(iprot);
                 struct.setNssiIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // NSTE
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.nste = new NotServingTabletException();
                 struct.nste.read(iprot);
                 struct.setNsteIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 3: // TMFE
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tmfe = new TooManyFilesException();
                 struct.tmfe.read(iprot);
                 struct.setTmfeIsSet(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, continueScan_result struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.success != null) {
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           struct.success.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.nssi != null) {
           oprot.writeFieldBegin(NSSI_FIELD_DESC);
           struct.nssi.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.nste != null) {
           oprot.writeFieldBegin(NSTE_FIELD_DESC);
           struct.nste.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.tmfe != null) {
           oprot.writeFieldBegin(TMFE_FIELD_DESC);
           struct.tmfe.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class continueScan_resultTupleSchemeFactory implements SchemeFactory {
       public continueScan_resultTupleScheme getScheme() {
         return new continueScan_resultTupleScheme();
       }
     }
 
     private static class continueScan_resultTupleScheme extends TupleScheme<continueScan_result> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, continueScan_result struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetSuccess()) {
           optionals.set(0);
         }
         if (struct.isSetNssi()) {
           optionals.set(1);
         }
         if (struct.isSetNste()) {
           optionals.set(2);
         }
         if (struct.isSetTmfe()) {
           optionals.set(3);
         }
         oprot.writeBitSet(optionals, 4);
         if (struct.isSetSuccess()) {
           struct.success.write(oprot);
         }
         if (struct.isSetNssi()) {
           struct.nssi.write(oprot);
         }
         if (struct.isSetNste()) {
           struct.nste.write(oprot);
         }
         if (struct.isSetTmfe()) {
           struct.tmfe.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, continueScan_result struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(4);
         if (incoming.get(0)) {
           struct.success = new org.apache.accumulo.core.data.thrift.ScanResult();
           struct.success.read(iprot);
           struct.setSuccessIsSet(true);
         }
         if (incoming.get(1)) {
           struct.nssi = new NoSuchScanIDException();
           struct.nssi.read(iprot);
           struct.setNssiIsSet(true);
         }
         if (incoming.get(2)) {
           struct.nste = new NotServingTabletException();
           struct.nste.read(iprot);
           struct.setNsteIsSet(true);
         }
         if (incoming.get(3)) {
           struct.tmfe = new TooManyFilesException();
           struct.tmfe.read(iprot);
           struct.setTmfeIsSet(true);
         }
       }
     }
 
   }
 
   public static class closeScan_args implements org.apache.thrift.TBase<closeScan_args, closeScan_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("closeScan_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField SCAN_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("scanID", org.apache.thrift.protocol.TType.I64, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new closeScan_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new closeScan_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public long scanID; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)2, "tinfo"),
       SCAN_ID((short)1, "scanID");
 
       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 2: // TINFO
             return TINFO;
           case 1: // SCAN_ID
             return SCAN_ID;
           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 __SCANID_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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.SCAN_ID, new org.apache.thrift.meta_data.FieldMetaData("scanID", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64          , "ScanID")));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(closeScan_args.class, metaDataMap);
     }
 
     public closeScan_args() {
     }
 
     public closeScan_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       long scanID)
     {
       this();
       this.tinfo = tinfo;
       this.scanID = scanID;
       setScanIDIsSet(true);
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public closeScan_args(closeScan_args other) {
       __isset_bitfield = other.__isset_bitfield;
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       this.scanID = other.scanID;
     }
 
     public closeScan_args deepCopy() {
       return new closeScan_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       setScanIDIsSet(false);
       this.scanID = 0;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public closeScan_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public long getScanID() {
       return this.scanID;
     }
 
     public closeScan_args setScanID(long scanID) {
       this.scanID = scanID;
       setScanIDIsSet(true);
       return this;
     }
 
     public void unsetScanID() {
       __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SCANID_ISSET_ID);
     }
 
     /** Returns true if field scanID is set (has been assigned a value) and false otherwise */
     public boolean isSetScanID() {
       return EncodingUtils.testBit(__isset_bitfield, __SCANID_ISSET_ID);
     }
 
     public void setScanIDIsSet(boolean value) {
       __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SCANID_ISSET_ID, value);
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case SCAN_ID:
         if (value == null) {
           unsetScanID();
         } else {
           setScanID((Long)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case SCAN_ID:
         return Long.valueOf(getScanID());
 
       }
       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 TINFO:
         return isSetTinfo();
       case SCAN_ID:
         return isSetScanID();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof closeScan_args)
         return this.equals((closeScan_args)that);
       return false;
     }
 
     public boolean equals(closeScan_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_scanID = true;
       boolean that_present_scanID = true;
       if (this_present_scanID || that_present_scanID) {
         if (!(this_present_scanID && that_present_scanID))
           return false;
         if (this.scanID != that.scanID)
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(closeScan_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       closeScan_args typedOther = (closeScan_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetScanID()).compareTo(typedOther.isSetScanID());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetScanID()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scanID, typedOther.scanID);
         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("closeScan_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("scanID:");
       sb.append(this.scanID);
       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 (tinfo != null) {
         tinfo.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, 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 closeScan_argsStandardSchemeFactory implements SchemeFactory {
       public closeScan_argsStandardScheme getScheme() {
         return new closeScan_argsStandardScheme();
       }
     }
 
     private static class closeScan_argsStandardScheme extends StandardScheme<closeScan_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, closeScan_args 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 2: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // SCAN_ID
               if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
                 struct.scanID = iprot.readI64();
                 struct.setScanIDIsSet(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, closeScan_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         oprot.writeFieldBegin(SCAN_ID_FIELD_DESC);
         oprot.writeI64(struct.scanID);
         oprot.writeFieldEnd();
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class closeScan_argsTupleSchemeFactory implements SchemeFactory {
       public closeScan_argsTupleScheme getScheme() {
         return new closeScan_argsTupleScheme();
       }
     }
 
     private static class closeScan_argsTupleScheme extends TupleScheme<closeScan_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, closeScan_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetScanID()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetScanID()) {
           oprot.writeI64(struct.scanID);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, closeScan_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.scanID = iprot.readI64();
           struct.setScanIDIsSet(true);
         }
       }
     }
 
   }
 
   public static class startMultiScan_args implements org.apache.thrift.TBase<startMultiScan_args, startMultiScan_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("startMultiScan_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)8);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField BATCH_FIELD_DESC = new org.apache.thrift.protocol.TField("batch", org.apache.thrift.protocol.TType.MAP, (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 SSI_LIST_FIELD_DESC = new org.apache.thrift.protocol.TField("ssiList", org.apache.thrift.protocol.TType.LIST, (short)4);
     private static final org.apache.thrift.protocol.TField SSIO_FIELD_DESC = new org.apache.thrift.protocol.TField("ssio", org.apache.thrift.protocol.TType.MAP, (short)5);
     private static final org.apache.thrift.protocol.TField AUTHORIZATIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("authorizations", org.apache.thrift.protocol.TType.LIST, (short)6);
     private static final org.apache.thrift.protocol.TField WAIT_FOR_WRITES_FIELD_DESC = new org.apache.thrift.protocol.TField("waitForWrites", org.apache.thrift.protocol.TType.BOOL, (short)7);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new startMultiScan_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new startMultiScan_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
     public Map<org.apache.accumulo.core.data.thrift.TKeyExtent,List<org.apache.accumulo.core.data.thrift.TRange>> batch; // required
     public List<org.apache.accumulo.core.data.thrift.TColumn> columns; // required
     public List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList; // required
     public Map<String,Map<String,String>> ssio; // required
     public List<ByteBuffer> authorizations; // required
     public boolean waitForWrites; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)8, "tinfo"),
       CREDENTIAL((short)1, "credential"),
       BATCH((short)2, "batch"),
       COLUMNS((short)3, "columns"),
       SSI_LIST((short)4, "ssiList"),
       SSIO((short)5, "ssio"),
       AUTHORIZATIONS((short)6, "authorizations"),
       WAIT_FOR_WRITES((short)7, "waitForWrites");
 
       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 8: // TINFO
             return TINFO;
           case 1: // CREDENTIAL
             return CREDENTIAL;
           case 2: // BATCH
             return BATCH;
           case 3: // COLUMNS
             return COLUMNS;
           case 4: // SSI_LIST
             return SSI_LIST;
           case 5: // SSIO
             return SSIO;
           case 6: // AUTHORIZATIONS
             return AUTHORIZATIONS;
           case 7: // WAIT_FOR_WRITES
             return WAIT_FOR_WRITES;
           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 __WAITFORWRITES_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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       tmpMap.put(_Fields.BATCH, new org.apache.thrift.meta_data.FieldMetaData("batch", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.MAP          , "ScanBatch")));
       tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           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, org.apache.accumulo.core.data.thrift.TColumn.class))));
       tmpMap.put(_Fields.SSI_LIST, new org.apache.thrift.meta_data.FieldMetaData("ssiList", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           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, org.apache.accumulo.core.data.thrift.IterInfo.class))));
       tmpMap.put(_Fields.SSIO, new org.apache.thrift.meta_data.FieldMetaData("ssio", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, 
               new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), 
               new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, 
                   new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), 
                   new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))));
       tmpMap.put(_Fields.AUTHORIZATIONS, new org.apache.thrift.meta_data.FieldMetaData("authorizations", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
               new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING              , true))));
       tmpMap.put(_Fields.WAIT_FOR_WRITES, new org.apache.thrift.meta_data.FieldMetaData("waitForWrites", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(startMultiScan_args.class, metaDataMap);
     }
 
     public startMultiScan_args() {
     }
 
     public startMultiScan_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential,
       Map<org.apache.accumulo.core.data.thrift.TKeyExtent,List<org.apache.accumulo.core.data.thrift.TRange>> batch,
       List<org.apache.accumulo.core.data.thrift.TColumn> columns,
       List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList,
       Map<String,Map<String,String>> ssio,
       List<ByteBuffer> authorizations,
       boolean waitForWrites)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
       this.batch = batch;
       this.columns = columns;
       this.ssiList = ssiList;
       this.ssio = ssio;
       this.authorizations = authorizations;
       this.waitForWrites = waitForWrites;
       setWaitForWritesIsSet(true);
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public startMultiScan_args(startMultiScan_args other) {
       __isset_bitfield = other.__isset_bitfield;
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
       if (other.isSetBatch()) {
         this.batch = other.batch;
       }
       if (other.isSetColumns()) {
         List<org.apache.accumulo.core.data.thrift.TColumn> __this__columns = new ArrayList<org.apache.accumulo.core.data.thrift.TColumn>();
         for (org.apache.accumulo.core.data.thrift.TColumn other_element : other.columns) {
           __this__columns.add(new org.apache.accumulo.core.data.thrift.TColumn(other_element));
         }
         this.columns = __this__columns;
       }
       if (other.isSetSsiList()) {
         List<org.apache.accumulo.core.data.thrift.IterInfo> __this__ssiList = new ArrayList<org.apache.accumulo.core.data.thrift.IterInfo>();
         for (org.apache.accumulo.core.data.thrift.IterInfo other_element : other.ssiList) {
           __this__ssiList.add(new org.apache.accumulo.core.data.thrift.IterInfo(other_element));
         }
         this.ssiList = __this__ssiList;
       }
       if (other.isSetSsio()) {
         Map<String,Map<String,String>> __this__ssio = new HashMap<String,Map<String,String>>();
         for (Map.Entry<String, Map<String,String>> other_element : other.ssio.entrySet()) {
 
           String other_element_key = other_element.getKey();
           Map<String,String> other_element_value = other_element.getValue();
 
           String __this__ssio_copy_key = other_element_key;
 
           Map<String,String> __this__ssio_copy_value = new HashMap<String,String>();
           for (Map.Entry<String, String> other_element_value_element : other_element_value.entrySet()) {
 
             String other_element_value_element_key = other_element_value_element.getKey();
             String other_element_value_element_value = other_element_value_element.getValue();
 
             String __this__ssio_copy_value_copy_key = other_element_value_element_key;
 
             String __this__ssio_copy_value_copy_value = other_element_value_element_value;
 
             __this__ssio_copy_value.put(__this__ssio_copy_value_copy_key, __this__ssio_copy_value_copy_value);
           }
 
           __this__ssio.put(__this__ssio_copy_key, __this__ssio_copy_value);
         }
         this.ssio = __this__ssio;
       }
       if (other.isSetAuthorizations()) {
         List<ByteBuffer> __this__authorizations = new ArrayList<ByteBuffer>();
         for (ByteBuffer other_element : other.authorizations) {
           ByteBuffer temp_binary_element = org.apache.thrift.TBaseHelper.copyBinary(other_element);
 ;
           __this__authorizations.add(temp_binary_element);
         }
         this.authorizations = __this__authorizations;
       }
       this.waitForWrites = other.waitForWrites;
     }
 
     public startMultiScan_args deepCopy() {
       return new startMultiScan_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
       this.batch = null;
       this.columns = null;
       this.ssiList = null;
       this.ssio = null;
       this.authorizations = null;
       setWaitForWritesIsSet(false);
       this.waitForWrites = false;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public startMultiScan_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public startMultiScan_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public int getBatchSize() {
       return (this.batch == null) ? 0 : this.batch.size();
     }
 
     public void putToBatch(org.apache.accumulo.core.data.thrift.TKeyExtent key, List<org.apache.accumulo.core.data.thrift.TRange> val) {
       if (this.batch == null) {
         this.batch = new HashMap<org.apache.accumulo.core.data.thrift.TKeyExtent,List<org.apache.accumulo.core.data.thrift.TRange>>();
       }
       this.batch.put(key, val);
     }
 
     public Map<org.apache.accumulo.core.data.thrift.TKeyExtent,List<org.apache.accumulo.core.data.thrift.TRange>> getBatch() {
       return this.batch;
     }
 
     public startMultiScan_args setBatch(Map<org.apache.accumulo.core.data.thrift.TKeyExtent,List<org.apache.accumulo.core.data.thrift.TRange>> batch) {
       this.batch = batch;
       return this;
     }
 
     public void unsetBatch() {
       this.batch = null;
     }
 
     /** Returns true if field batch is set (has been assigned a value) and false otherwise */
     public boolean isSetBatch() {
       return this.batch != null;
     }
 
     public void setBatchIsSet(boolean value) {
       if (!value) {
         this.batch = null;
       }
     }
 
     public int getColumnsSize() {
       return (this.columns == null) ? 0 : this.columns.size();
     }
 
     public java.util.Iterator<org.apache.accumulo.core.data.thrift.TColumn> getColumnsIterator() {
       return (this.columns == null) ? null : this.columns.iterator();
     }
 
     public void addToColumns(org.apache.accumulo.core.data.thrift.TColumn elem) {
       if (this.columns == null) {
         this.columns = new ArrayList<org.apache.accumulo.core.data.thrift.TColumn>();
       }
       this.columns.add(elem);
     }
 
     public List<org.apache.accumulo.core.data.thrift.TColumn> getColumns() {
       return this.columns;
     }
 
     public startMultiScan_args setColumns(List<org.apache.accumulo.core.data.thrift.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 getSsiListSize() {
       return (this.ssiList == null) ? 0 : this.ssiList.size();
     }
 
     public java.util.Iterator<org.apache.accumulo.core.data.thrift.IterInfo> getSsiListIterator() {
       return (this.ssiList == null) ? null : this.ssiList.iterator();
     }
 
     public void addToSsiList(org.apache.accumulo.core.data.thrift.IterInfo elem) {
       if (this.ssiList == null) {
         this.ssiList = new ArrayList<org.apache.accumulo.core.data.thrift.IterInfo>();
       }
       this.ssiList.add(elem);
     }
 
     public List<org.apache.accumulo.core.data.thrift.IterInfo> getSsiList() {
       return this.ssiList;
     }
 
     public startMultiScan_args setSsiList(List<org.apache.accumulo.core.data.thrift.IterInfo> ssiList) {
       this.ssiList = ssiList;
       return this;
     }
 
     public void unsetSsiList() {
       this.ssiList = null;
     }
 
     /** Returns true if field ssiList is set (has been assigned a value) and false otherwise */
     public boolean isSetSsiList() {
       return this.ssiList != null;
     }
 
     public void setSsiListIsSet(boolean value) {
       if (!value) {
         this.ssiList = null;
       }
     }
 
     public int getSsioSize() {
       return (this.ssio == null) ? 0 : this.ssio.size();
     }
 
     public void putToSsio(String key, Map<String,String> val) {
       if (this.ssio == null) {
         this.ssio = new HashMap<String,Map<String,String>>();
       }
       this.ssio.put(key, val);
     }
 
     public Map<String,Map<String,String>> getSsio() {
       return this.ssio;
     }
 
     public startMultiScan_args setSsio(Map<String,Map<String,String>> ssio) {
       this.ssio = ssio;
       return this;
     }
 
     public void unsetSsio() {
       this.ssio = null;
     }
 
     /** Returns true if field ssio is set (has been assigned a value) and false otherwise */
     public boolean isSetSsio() {
       return this.ssio != null;
     }
 
     public void setSsioIsSet(boolean value) {
       if (!value) {
         this.ssio = null;
       }
     }
 
     public int getAuthorizationsSize() {
       return (this.authorizations == null) ? 0 : this.authorizations.size();
     }
 
     public java.util.Iterator<ByteBuffer> getAuthorizationsIterator() {
       return (this.authorizations == null) ? null : this.authorizations.iterator();
     }
 
     public void addToAuthorizations(ByteBuffer elem) {
       if (this.authorizations == null) {
         this.authorizations = new ArrayList<ByteBuffer>();
       }
       this.authorizations.add(elem);
     }
 
     public List<ByteBuffer> getAuthorizations() {
       return this.authorizations;
     }
 
     public startMultiScan_args setAuthorizations(List<ByteBuffer> 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 isWaitForWrites() {
       return this.waitForWrites;
     }
 
     public startMultiScan_args setWaitForWrites(boolean waitForWrites) {
       this.waitForWrites = waitForWrites;
       setWaitForWritesIsSet(true);
       return this;
     }
 
     public void unsetWaitForWrites() {
       __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __WAITFORWRITES_ISSET_ID);
     }
 
     /** Returns true if field waitForWrites is set (has been assigned a value) and false otherwise */
     public boolean isSetWaitForWrites() {
       return EncodingUtils.testBit(__isset_bitfield, __WAITFORWRITES_ISSET_ID);
     }
 
     public void setWaitForWritesIsSet(boolean value) {
       __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __WAITFORWRITES_ISSET_ID, value);
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       case BATCH:
         if (value == null) {
           unsetBatch();
         } else {
           setBatch((Map<org.apache.accumulo.core.data.thrift.TKeyExtent,List<org.apache.accumulo.core.data.thrift.TRange>>)value);
         }
         break;
 
       case COLUMNS:
         if (value == null) {
           unsetColumns();
         } else {
           setColumns((List<org.apache.accumulo.core.data.thrift.TColumn>)value);
         }
         break;
 
       case SSI_LIST:
         if (value == null) {
           unsetSsiList();
         } else {
           setSsiList((List<org.apache.accumulo.core.data.thrift.IterInfo>)value);
         }
         break;
 
       case SSIO:
         if (value == null) {
           unsetSsio();
         } else {
           setSsio((Map<String,Map<String,String>>)value);
         }
         break;
 
       case AUTHORIZATIONS:
         if (value == null) {
           unsetAuthorizations();
         } else {
           setAuthorizations((List<ByteBuffer>)value);
         }
         break;
 
       case WAIT_FOR_WRITES:
         if (value == null) {
           unsetWaitForWrites();
         } else {
           setWaitForWrites((Boolean)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       case BATCH:
         return getBatch();
 
       case COLUMNS:
         return getColumns();
 
       case SSI_LIST:
         return getSsiList();
 
       case SSIO:
         return getSsio();
 
       case AUTHORIZATIONS:
         return getAuthorizations();
 
       case WAIT_FOR_WRITES:
         return Boolean.valueOf(isWaitForWrites());
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       case BATCH:
         return isSetBatch();
       case COLUMNS:
         return isSetColumns();
       case SSI_LIST:
         return isSetSsiList();
       case SSIO:
         return isSetSsio();
       case AUTHORIZATIONS:
         return isSetAuthorizations();
       case WAIT_FOR_WRITES:
         return isSetWaitForWrites();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof startMultiScan_args)
         return this.equals((startMultiScan_args)that);
       return false;
     }
 
     public boolean equals(startMultiScan_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       boolean this_present_batch = true && this.isSetBatch();
       boolean that_present_batch = true && that.isSetBatch();
       if (this_present_batch || that_present_batch) {
         if (!(this_present_batch && that_present_batch))
           return false;
         if (!this.batch.equals(that.batch))
           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_ssiList = true && this.isSetSsiList();
       boolean that_present_ssiList = true && that.isSetSsiList();
       if (this_present_ssiList || that_present_ssiList) {
         if (!(this_present_ssiList && that_present_ssiList))
           return false;
         if (!this.ssiList.equals(that.ssiList))
           return false;
       }
 
       boolean this_present_ssio = true && this.isSetSsio();
       boolean that_present_ssio = true && that.isSetSsio();
       if (this_present_ssio || that_present_ssio) {
         if (!(this_present_ssio && that_present_ssio))
           return false;
         if (!this.ssio.equals(that.ssio))
           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_waitForWrites = true;
       boolean that_present_waitForWrites = true;
       if (this_present_waitForWrites || that_present_waitForWrites) {
         if (!(this_present_waitForWrites && that_present_waitForWrites))
           return false;
         if (this.waitForWrites != that.waitForWrites)
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(startMultiScan_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       startMultiScan_args typedOther = (startMultiScan_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetBatch()).compareTo(typedOther.isSetBatch());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetBatch()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.batch, typedOther.batch);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetColumns()).compareTo(typedOther.isSetColumns());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetColumns()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetSsiList()).compareTo(typedOther.isSetSsiList());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSsiList()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ssiList, typedOther.ssiList);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetSsio()).compareTo(typedOther.isSetSsio());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSsio()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ssio, typedOther.ssio);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetAuthorizations()).compareTo(typedOther.isSetAuthorizations());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetAuthorizations()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authorizations, typedOther.authorizations);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetWaitForWrites()).compareTo(typedOther.isSetWaitForWrites());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetWaitForWrites()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.waitForWrites, typedOther.waitForWrites);
         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("startMultiScan_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("batch:");
       if (this.batch == null) {
         sb.append("null");
       } else {
         sb.append(this.batch);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("columns:");
       if (this.columns == null) {
         sb.append("null");
       } else {
         sb.append(this.columns);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("ssiList:");
       if (this.ssiList == null) {
         sb.append("null");
       } else {
         sb.append(this.ssiList);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("ssio:");
       if (this.ssio == null) {
         sb.append("null");
       } else {
         sb.append(this.ssio);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("authorizations:");
       if (this.authorizations == null) {
         sb.append("null");
       } else {
         sb.append(this.authorizations);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("waitForWrites:");
       sb.append(this.waitForWrites);
       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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.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, 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 startMultiScan_argsStandardSchemeFactory implements SchemeFactory {
       public startMultiScan_argsStandardScheme getScheme() {
         return new startMultiScan_argsStandardScheme();
       }
     }
 
     private static class startMultiScan_argsStandardScheme extends StandardScheme<startMultiScan_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, startMultiScan_args 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 8: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // BATCH
               if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
                 {
                   org.apache.thrift.protocol.TMap _map150 = iprot.readMapBegin();
                   struct.batch = new HashMap<org.apache.accumulo.core.data.thrift.TKeyExtent,List<org.apache.accumulo.core.data.thrift.TRange>>(2*_map150.size);
                   for (int _i151 = 0; _i151 < _map150.size; ++_i151)
                   {
                     org.apache.accumulo.core.data.thrift.TKeyExtent _key152; // required
                     List<org.apache.accumulo.core.data.thrift.TRange> _val153; // required
                     _key152 = new org.apache.accumulo.core.data.thrift.TKeyExtent();
                     _key152.read(iprot);
                     {
                       org.apache.thrift.protocol.TList _list154 = iprot.readListBegin();
                       _val153 = new ArrayList<org.apache.accumulo.core.data.thrift.TRange>(_list154.size);
                       for (int _i155 = 0; _i155 < _list154.size; ++_i155)
                       {
                         org.apache.accumulo.core.data.thrift.TRange _elem156; // required
                         _elem156 = new org.apache.accumulo.core.data.thrift.TRange();
                         _elem156.read(iprot);
                         _val153.add(_elem156);
                       }
                       iprot.readListEnd();
                     }
                     struct.batch.put(_key152, _val153);
                   }
                   iprot.readMapEnd();
                 }
                 struct.setBatchIsSet(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 _list157 = iprot.readListBegin();
                   struct.columns = new ArrayList<org.apache.accumulo.core.data.thrift.TColumn>(_list157.size);
                   for (int _i158 = 0; _i158 < _list157.size; ++_i158)
                   {
                     org.apache.accumulo.core.data.thrift.TColumn _elem159; // required
                     _elem159 = new org.apache.accumulo.core.data.thrift.TColumn();
                     _elem159.read(iprot);
                     struct.columns.add(_elem159);
                   }
                   iprot.readListEnd();
                 }
                 struct.setColumnsIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 4: // SSI_LIST
               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                 {
                   org.apache.thrift.protocol.TList _list160 = iprot.readListBegin();
                   struct.ssiList = new ArrayList<org.apache.accumulo.core.data.thrift.IterInfo>(_list160.size);
                   for (int _i161 = 0; _i161 < _list160.size; ++_i161)
                   {
                     org.apache.accumulo.core.data.thrift.IterInfo _elem162; // required
                     _elem162 = new org.apache.accumulo.core.data.thrift.IterInfo();
                     _elem162.read(iprot);
                     struct.ssiList.add(_elem162);
                   }
                   iprot.readListEnd();
                 }
                 struct.setSsiListIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 5: // SSIO
               if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
                 {
                   org.apache.thrift.protocol.TMap _map163 = iprot.readMapBegin();
                   struct.ssio = new HashMap<String,Map<String,String>>(2*_map163.size);
                   for (int _i164 = 0; _i164 < _map163.size; ++_i164)
                   {
                     String _key165; // required
                     Map<String,String> _val166; // required
                     _key165 = iprot.readString();
                     {
                       org.apache.thrift.protocol.TMap _map167 = iprot.readMapBegin();
                       _val166 = new HashMap<String,String>(2*_map167.size);
                       for (int _i168 = 0; _i168 < _map167.size; ++_i168)
                       {
                         String _key169; // required
                         String _val170; // required
                         _key169 = iprot.readString();
                         _val170 = iprot.readString();
                         _val166.put(_key169, _val170);
                       }
                       iprot.readMapEnd();
                     }
                     struct.ssio.put(_key165, _val166);
                   }
                   iprot.readMapEnd();
                 }
                 struct.setSsioIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 6: // AUTHORIZATIONS
               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                 {
                   org.apache.thrift.protocol.TList _list171 = iprot.readListBegin();
                   struct.authorizations = new ArrayList<ByteBuffer>(_list171.size);
                   for (int _i172 = 0; _i172 < _list171.size; ++_i172)
                   {
                     ByteBuffer _elem173; // required
                     _elem173 = iprot.readBinary();
                     struct.authorizations.add(_elem173);
                   }
                   iprot.readListEnd();
                 }
                 struct.setAuthorizationsIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 7: // WAIT_FOR_WRITES
               if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
                 struct.waitForWrites = iprot.readBool();
                 struct.setWaitForWritesIsSet(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, startMultiScan_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.batch != null) {
           oprot.writeFieldBegin(BATCH_FIELD_DESC);
           {
             oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRUCT, org.apache.thrift.protocol.TType.LIST, struct.batch.size()));
             for (Map.Entry<org.apache.accumulo.core.data.thrift.TKeyExtent, List<org.apache.accumulo.core.data.thrift.TRange>> _iter174 : struct.batch.entrySet())
             {
               _iter174.getKey().write(oprot);
               {
                 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter174.getValue().size()));
                 for (org.apache.accumulo.core.data.thrift.TRange _iter175 : _iter174.getValue())
                 {
                   _iter175.write(oprot);
                 }
                 oprot.writeListEnd();
               }
             }
             oprot.writeMapEnd();
           }
           oprot.writeFieldEnd();
         }
         if (struct.columns != null) {
           oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.columns.size()));
             for (org.apache.accumulo.core.data.thrift.TColumn _iter176 : struct.columns)
             {
               _iter176.write(oprot);
             }
             oprot.writeListEnd();
           }
           oprot.writeFieldEnd();
         }
         if (struct.ssiList != null) {
           oprot.writeFieldBegin(SSI_LIST_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.ssiList.size()));
             for (org.apache.accumulo.core.data.thrift.IterInfo _iter177 : struct.ssiList)
             {
               _iter177.write(oprot);
             }
             oprot.writeListEnd();
           }
           oprot.writeFieldEnd();
         }
         if (struct.ssio != null) {
           oprot.writeFieldBegin(SSIO_FIELD_DESC);
           {
             oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.MAP, struct.ssio.size()));
             for (Map.Entry<String, Map<String,String>> _iter178 : struct.ssio.entrySet())
             {
               oprot.writeString(_iter178.getKey());
               {
                 oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter178.getValue().size()));
                 for (Map.Entry<String, String> _iter179 : _iter178.getValue().entrySet())
                 {
                   oprot.writeString(_iter179.getKey());
                   oprot.writeString(_iter179.getValue());
                 }
                 oprot.writeMapEnd();
               }
             }
             oprot.writeMapEnd();
           }
           oprot.writeFieldEnd();
         }
         if (struct.authorizations != null) {
           oprot.writeFieldBegin(AUTHORIZATIONS_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.authorizations.size()));
             for (ByteBuffer _iter180 : struct.authorizations)
             {
               oprot.writeBinary(_iter180);
             }
             oprot.writeListEnd();
           }
           oprot.writeFieldEnd();
         }
         oprot.writeFieldBegin(WAIT_FOR_WRITES_FIELD_DESC);
         oprot.writeBool(struct.waitForWrites);
         oprot.writeFieldEnd();
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class startMultiScan_argsTupleSchemeFactory implements SchemeFactory {
       public startMultiScan_argsTupleScheme getScheme() {
         return new startMultiScan_argsTupleScheme();
       }
     }
 
     private static class startMultiScan_argsTupleScheme extends TupleScheme<startMultiScan_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, startMultiScan_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         if (struct.isSetBatch()) {
           optionals.set(2);
         }
         if (struct.isSetColumns()) {
           optionals.set(3);
         }
         if (struct.isSetSsiList()) {
           optionals.set(4);
         }
         if (struct.isSetSsio()) {
           optionals.set(5);
         }
         if (struct.isSetAuthorizations()) {
           optionals.set(6);
         }
         if (struct.isSetWaitForWrites()) {
           optionals.set(7);
         }
         oprot.writeBitSet(optionals, 8);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
         if (struct.isSetBatch()) {
           {
             oprot.writeI32(struct.batch.size());
             for (Map.Entry<org.apache.accumulo.core.data.thrift.TKeyExtent, List<org.apache.accumulo.core.data.thrift.TRange>> _iter181 : struct.batch.entrySet())
             {
               _iter181.getKey().write(oprot);
               {
                 oprot.writeI32(_iter181.getValue().size());
                 for (org.apache.accumulo.core.data.thrift.TRange _iter182 : _iter181.getValue())
                 {
                   _iter182.write(oprot);
                 }
               }
             }
           }
         }
         if (struct.isSetColumns()) {
           {
             oprot.writeI32(struct.columns.size());
             for (org.apache.accumulo.core.data.thrift.TColumn _iter183 : struct.columns)
             {
               _iter183.write(oprot);
             }
           }
         }
         if (struct.isSetSsiList()) {
           {
             oprot.writeI32(struct.ssiList.size());
             for (org.apache.accumulo.core.data.thrift.IterInfo _iter184 : struct.ssiList)
             {
               _iter184.write(oprot);
             }
           }
         }
         if (struct.isSetSsio()) {
           {
             oprot.writeI32(struct.ssio.size());
             for (Map.Entry<String, Map<String,String>> _iter185 : struct.ssio.entrySet())
             {
               oprot.writeString(_iter185.getKey());
               {
                 oprot.writeI32(_iter185.getValue().size());
                 for (Map.Entry<String, String> _iter186 : _iter185.getValue().entrySet())
                 {
                   oprot.writeString(_iter186.getKey());
                   oprot.writeString(_iter186.getValue());
                 }
               }
             }
           }
         }
         if (struct.isSetAuthorizations()) {
           {
             oprot.writeI32(struct.authorizations.size());
             for (ByteBuffer _iter187 : struct.authorizations)
             {
               oprot.writeBinary(_iter187);
             }
           }
         }
         if (struct.isSetWaitForWrites()) {
           oprot.writeBool(struct.waitForWrites);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, startMultiScan_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(8);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
         if (incoming.get(2)) {
           {
             org.apache.thrift.protocol.TMap _map188 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRUCT, org.apache.thrift.protocol.TType.LIST, iprot.readI32());
             struct.batch = new HashMap<org.apache.accumulo.core.data.thrift.TKeyExtent,List<org.apache.accumulo.core.data.thrift.TRange>>(2*_map188.size);
             for (int _i189 = 0; _i189 < _map188.size; ++_i189)
             {
               org.apache.accumulo.core.data.thrift.TKeyExtent _key190; // required
               List<org.apache.accumulo.core.data.thrift.TRange> _val191; // required
               _key190 = new org.apache.accumulo.core.data.thrift.TKeyExtent();
               _key190.read(iprot);
               {
                 org.apache.thrift.protocol.TList _list192 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
                 _val191 = new ArrayList<org.apache.accumulo.core.data.thrift.TRange>(_list192.size);
                 for (int _i193 = 0; _i193 < _list192.size; ++_i193)
                 {
                   org.apache.accumulo.core.data.thrift.TRange _elem194; // required
                   _elem194 = new org.apache.accumulo.core.data.thrift.TRange();
                   _elem194.read(iprot);
                   _val191.add(_elem194);
                 }
               }
               struct.batch.put(_key190, _val191);
             }
           }
           struct.setBatchIsSet(true);
         }
         if (incoming.get(3)) {
           {
             org.apache.thrift.protocol.TList _list195 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
             struct.columns = new ArrayList<org.apache.accumulo.core.data.thrift.TColumn>(_list195.size);
             for (int _i196 = 0; _i196 < _list195.size; ++_i196)
             {
               org.apache.accumulo.core.data.thrift.TColumn _elem197; // required
               _elem197 = new org.apache.accumulo.core.data.thrift.TColumn();
               _elem197.read(iprot);
               struct.columns.add(_elem197);
             }
           }
           struct.setColumnsIsSet(true);
         }
         if (incoming.get(4)) {
           {
             org.apache.thrift.protocol.TList _list198 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
             struct.ssiList = new ArrayList<org.apache.accumulo.core.data.thrift.IterInfo>(_list198.size);
             for (int _i199 = 0; _i199 < _list198.size; ++_i199)
             {
               org.apache.accumulo.core.data.thrift.IterInfo _elem200; // required
               _elem200 = new org.apache.accumulo.core.data.thrift.IterInfo();
               _elem200.read(iprot);
               struct.ssiList.add(_elem200);
             }
           }
           struct.setSsiListIsSet(true);
         }
         if (incoming.get(5)) {
           {
             org.apache.thrift.protocol.TMap _map201 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.MAP, iprot.readI32());
             struct.ssio = new HashMap<String,Map<String,String>>(2*_map201.size);
             for (int _i202 = 0; _i202 < _map201.size; ++_i202)
             {
               String _key203; // required
               Map<String,String> _val204; // required
               _key203 = iprot.readString();
               {
                 org.apache.thrift.protocol.TMap _map205 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32());
                 _val204 = new HashMap<String,String>(2*_map205.size);
                 for (int _i206 = 0; _i206 < _map205.size; ++_i206)
                 {
                   String _key207; // required
                   String _val208; // required
                   _key207 = iprot.readString();
                   _val208 = iprot.readString();
                   _val204.put(_key207, _val208);
                 }
               }
               struct.ssio.put(_key203, _val204);
             }
           }
           struct.setSsioIsSet(true);
         }
         if (incoming.get(6)) {
           {
             org.apache.thrift.protocol.TList _list209 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
             struct.authorizations = new ArrayList<ByteBuffer>(_list209.size);
             for (int _i210 = 0; _i210 < _list209.size; ++_i210)
             {
               ByteBuffer _elem211; // required
               _elem211 = iprot.readBinary();
               struct.authorizations.add(_elem211);
             }
           }
           struct.setAuthorizationsIsSet(true);
         }
         if (incoming.get(7)) {
           struct.waitForWrites = iprot.readBool();
           struct.setWaitForWritesIsSet(true);
         }
       }
     }
 
   }
 
   public static class startMultiScan_result implements org.apache.thrift.TBase<startMultiScan_result, startMultiScan_result._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("startMultiScan_result");
 
     private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
     private static final org.apache.thrift.protocol.TField SEC_FIELD_DESC = new org.apache.thrift.protocol.TField("sec", org.apache.thrift.protocol.TType.STRUCT, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new startMultiScan_resultStandardSchemeFactory());
       schemes.put(TupleScheme.class, new startMultiScan_resultTupleSchemeFactory());
     }
 
     public org.apache.accumulo.core.data.thrift.InitialMultiScan success; // required
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException sec; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       SUCCESS((short)0, "success"),
       SEC((short)1, "sec");
 
       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 0: // SUCCESS
             return SUCCESS;
           case 1: // SEC
             return SEC;
           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
     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.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.data.thrift.InitialMultiScan.class)));
       tmpMap.put(_Fields.SEC, new org.apache.thrift.meta_data.FieldMetaData("sec", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(startMultiScan_result.class, metaDataMap);
     }
 
     public startMultiScan_result() {
     }
 
     public startMultiScan_result(
       org.apache.accumulo.core.data.thrift.InitialMultiScan success,
       org.apache.accumulo.core.security.thrift.ThriftSecurityException sec)
     {
       this();
       this.success = success;
       this.sec = sec;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public startMultiScan_result(startMultiScan_result other) {
       if (other.isSetSuccess()) {
         this.success = new org.apache.accumulo.core.data.thrift.InitialMultiScan(other.success);
       }
       if (other.isSetSec()) {
         this.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException(other.sec);
       }
     }
 
     public startMultiScan_result deepCopy() {
       return new startMultiScan_result(this);
     }
 
     @Override
     public void clear() {
       this.success = null;
       this.sec = null;
     }
 
     public org.apache.accumulo.core.data.thrift.InitialMultiScan getSuccess() {
       return this.success;
     }
 
     public startMultiScan_result setSuccess(org.apache.accumulo.core.data.thrift.InitialMultiScan success) {
       this.success = success;
       return this;
     }
 
     public void unsetSuccess() {
       this.success = null;
     }
 
     /** Returns true if field success is set (has been assigned a value) and false otherwise */
     public boolean isSetSuccess() {
       return this.success != null;
     }
 
     public void setSuccessIsSet(boolean value) {
       if (!value) {
         this.success = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException getSec() {
       return this.sec;
     }
 
     public startMultiScan_result setSec(org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
       this.sec = sec;
       return this;
     }
 
     public void unsetSec() {
       this.sec = null;
     }
 
     /** Returns true if field sec is set (has been assigned a value) and false otherwise */
     public boolean isSetSec() {
       return this.sec != null;
     }
 
     public void setSecIsSet(boolean value) {
       if (!value) {
         this.sec = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
           setSuccess((org.apache.accumulo.core.data.thrift.InitialMultiScan)value);
         }
         break;
 
       case SEC:
         if (value == null) {
           unsetSec();
         } else {
           setSec((org.apache.accumulo.core.security.thrift.ThriftSecurityException)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
         return getSuccess();
 
       case SEC:
         return getSec();
 
       }
       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 SUCCESS:
         return isSetSuccess();
       case SEC:
         return isSetSec();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof startMultiScan_result)
         return this.equals((startMultiScan_result)that);
       return false;
     }
 
     public boolean equals(startMultiScan_result that) {
       if (that == null)
         return false;
 
       boolean this_present_success = true && this.isSetSuccess();
       boolean that_present_success = true && that.isSetSuccess();
       if (this_present_success || that_present_success) {
         if (!(this_present_success && that_present_success))
           return false;
         if (!this.success.equals(that.success))
           return false;
       }
 
       boolean this_present_sec = true && this.isSetSec();
       boolean that_present_sec = true && that.isSetSec();
       if (this_present_sec || that_present_sec) {
         if (!(this_present_sec && that_present_sec))
           return false;
         if (!this.sec.equals(that.sec))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(startMultiScan_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       startMultiScan_result typedOther = (startMultiScan_result)other;
 
       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSuccess()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetSec()).compareTo(typedOther.isSetSec());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSec()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sec, typedOther.sec);
         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("startMultiScan_result(");
       boolean first = true;
 
       sb.append("success:");
       if (this.success == null) {
         sb.append("null");
       } else {
         sb.append(this.success);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("sec:");
       if (this.sec == null) {
         sb.append("null");
       } else {
         sb.append(this.sec);
       }
       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 (success != null) {
         success.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, ClassNotFoundException {
       try {
         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 startMultiScan_resultStandardSchemeFactory implements SchemeFactory {
       public startMultiScan_resultStandardScheme getScheme() {
         return new startMultiScan_resultStandardScheme();
       }
     }
 
     private static class startMultiScan_resultStandardScheme extends StandardScheme<startMultiScan_result> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, startMultiScan_result 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 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.success = new org.apache.accumulo.core.data.thrift.InitialMultiScan();
                 struct.success.read(iprot);
                 struct.setSuccessIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // SEC
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
                 struct.sec.read(iprot);
                 struct.setSecIsSet(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, startMultiScan_result struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.success != null) {
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           struct.success.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.sec != null) {
           oprot.writeFieldBegin(SEC_FIELD_DESC);
           struct.sec.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class startMultiScan_resultTupleSchemeFactory implements SchemeFactory {
       public startMultiScan_resultTupleScheme getScheme() {
         return new startMultiScan_resultTupleScheme();
       }
     }
 
     private static class startMultiScan_resultTupleScheme extends TupleScheme<startMultiScan_result> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, startMultiScan_result struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetSuccess()) {
           optionals.set(0);
         }
         if (struct.isSetSec()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetSuccess()) {
           struct.success.write(oprot);
         }
         if (struct.isSetSec()) {
           struct.sec.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, startMultiScan_result struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           struct.success = new org.apache.accumulo.core.data.thrift.InitialMultiScan();
           struct.success.read(iprot);
           struct.setSuccessIsSet(true);
         }
         if (incoming.get(1)) {
           struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
           struct.sec.read(iprot);
           struct.setSecIsSet(true);
         }
       }
     }
 
   }
 
   public static class continueMultiScan_args implements org.apache.thrift.TBase<continueMultiScan_args, continueMultiScan_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("continueMultiScan_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField SCAN_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("scanID", org.apache.thrift.protocol.TType.I64, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new continueMultiScan_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new continueMultiScan_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public long scanID; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)2, "tinfo"),
       SCAN_ID((short)1, "scanID");
 
       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 2: // TINFO
             return TINFO;
           case 1: // SCAN_ID
             return SCAN_ID;
           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 __SCANID_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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.SCAN_ID, new org.apache.thrift.meta_data.FieldMetaData("scanID", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64          , "ScanID")));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(continueMultiScan_args.class, metaDataMap);
     }
 
     public continueMultiScan_args() {
     }
 
     public continueMultiScan_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       long scanID)
     {
       this();
       this.tinfo = tinfo;
       this.scanID = scanID;
       setScanIDIsSet(true);
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public continueMultiScan_args(continueMultiScan_args other) {
       __isset_bitfield = other.__isset_bitfield;
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       this.scanID = other.scanID;
     }
 
     public continueMultiScan_args deepCopy() {
       return new continueMultiScan_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       setScanIDIsSet(false);
       this.scanID = 0;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public continueMultiScan_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public long getScanID() {
       return this.scanID;
     }
 
     public continueMultiScan_args setScanID(long scanID) {
       this.scanID = scanID;
       setScanIDIsSet(true);
       return this;
     }
 
     public void unsetScanID() {
       __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SCANID_ISSET_ID);
     }
 
     /** Returns true if field scanID is set (has been assigned a value) and false otherwise */
     public boolean isSetScanID() {
       return EncodingUtils.testBit(__isset_bitfield, __SCANID_ISSET_ID);
     }
 
     public void setScanIDIsSet(boolean value) {
       __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SCANID_ISSET_ID, value);
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case SCAN_ID:
         if (value == null) {
           unsetScanID();
         } else {
           setScanID((Long)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case SCAN_ID:
         return Long.valueOf(getScanID());
 
       }
       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 TINFO:
         return isSetTinfo();
       case SCAN_ID:
         return isSetScanID();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof continueMultiScan_args)
         return this.equals((continueMultiScan_args)that);
       return false;
     }
 
     public boolean equals(continueMultiScan_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_scanID = true;
       boolean that_present_scanID = true;
       if (this_present_scanID || that_present_scanID) {
         if (!(this_present_scanID && that_present_scanID))
           return false;
         if (this.scanID != that.scanID)
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(continueMultiScan_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       continueMultiScan_args typedOther = (continueMultiScan_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetScanID()).compareTo(typedOther.isSetScanID());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetScanID()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scanID, typedOther.scanID);
         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("continueMultiScan_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("scanID:");
       sb.append(this.scanID);
       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 (tinfo != null) {
         tinfo.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, 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 continueMultiScan_argsStandardSchemeFactory implements SchemeFactory {
       public continueMultiScan_argsStandardScheme getScheme() {
         return new continueMultiScan_argsStandardScheme();
       }
     }
 
     private static class continueMultiScan_argsStandardScheme extends StandardScheme<continueMultiScan_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, continueMultiScan_args 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 2: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // SCAN_ID
               if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
                 struct.scanID = iprot.readI64();
                 struct.setScanIDIsSet(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, continueMultiScan_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         oprot.writeFieldBegin(SCAN_ID_FIELD_DESC);
         oprot.writeI64(struct.scanID);
         oprot.writeFieldEnd();
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class continueMultiScan_argsTupleSchemeFactory implements SchemeFactory {
       public continueMultiScan_argsTupleScheme getScheme() {
         return new continueMultiScan_argsTupleScheme();
       }
     }
 
     private static class continueMultiScan_argsTupleScheme extends TupleScheme<continueMultiScan_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, continueMultiScan_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetScanID()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetScanID()) {
           oprot.writeI64(struct.scanID);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, continueMultiScan_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.scanID = iprot.readI64();
           struct.setScanIDIsSet(true);
         }
       }
     }
 
   }
 
   public static class continueMultiScan_result implements org.apache.thrift.TBase<continueMultiScan_result, continueMultiScan_result._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("continueMultiScan_result");
 
     private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
     private static final org.apache.thrift.protocol.TField NSSI_FIELD_DESC = new org.apache.thrift.protocol.TField("nssi", org.apache.thrift.protocol.TType.STRUCT, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new continueMultiScan_resultStandardSchemeFactory());
       schemes.put(TupleScheme.class, new continueMultiScan_resultTupleSchemeFactory());
     }
 
     public org.apache.accumulo.core.data.thrift.MultiScanResult success; // required
     public NoSuchScanIDException nssi; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       SUCCESS((short)0, "success"),
       NSSI((short)1, "nssi");
 
       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 0: // SUCCESS
             return SUCCESS;
           case 1: // NSSI
             return NSSI;
           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
     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.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.data.thrift.MultiScanResult.class)));
       tmpMap.put(_Fields.NSSI, new org.apache.thrift.meta_data.FieldMetaData("nssi", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(continueMultiScan_result.class, metaDataMap);
     }
 
     public continueMultiScan_result() {
     }
 
     public continueMultiScan_result(
       org.apache.accumulo.core.data.thrift.MultiScanResult success,
       NoSuchScanIDException nssi)
     {
       this();
       this.success = success;
       this.nssi = nssi;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public continueMultiScan_result(continueMultiScan_result other) {
       if (other.isSetSuccess()) {
         this.success = new org.apache.accumulo.core.data.thrift.MultiScanResult(other.success);
       }
       if (other.isSetNssi()) {
         this.nssi = new NoSuchScanIDException(other.nssi);
       }
     }
 
     public continueMultiScan_result deepCopy() {
       return new continueMultiScan_result(this);
     }
 
     @Override
     public void clear() {
       this.success = null;
       this.nssi = null;
     }
 
     public org.apache.accumulo.core.data.thrift.MultiScanResult getSuccess() {
       return this.success;
     }
 
     public continueMultiScan_result setSuccess(org.apache.accumulo.core.data.thrift.MultiScanResult success) {
       this.success = success;
       return this;
     }
 
     public void unsetSuccess() {
       this.success = null;
     }
 
     /** Returns true if field success is set (has been assigned a value) and false otherwise */
     public boolean isSetSuccess() {
       return this.success != null;
     }
 
     public void setSuccessIsSet(boolean value) {
       if (!value) {
         this.success = null;
       }
     }
 
     public NoSuchScanIDException getNssi() {
       return this.nssi;
     }
 
     public continueMultiScan_result setNssi(NoSuchScanIDException nssi) {
       this.nssi = nssi;
       return this;
     }
 
     public void unsetNssi() {
       this.nssi = null;
     }
 
     /** Returns true if field nssi is set (has been assigned a value) and false otherwise */
     public boolean isSetNssi() {
       return this.nssi != null;
     }
 
     public void setNssiIsSet(boolean value) {
       if (!value) {
         this.nssi = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
           setSuccess((org.apache.accumulo.core.data.thrift.MultiScanResult)value);
         }
         break;
 
       case NSSI:
         if (value == null) {
           unsetNssi();
         } else {
           setNssi((NoSuchScanIDException)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
         return getSuccess();
 
       case NSSI:
         return getNssi();
 
       }
       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 SUCCESS:
         return isSetSuccess();
       case NSSI:
         return isSetNssi();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof continueMultiScan_result)
         return this.equals((continueMultiScan_result)that);
       return false;
     }
 
     public boolean equals(continueMultiScan_result that) {
       if (that == null)
         return false;
 
       boolean this_present_success = true && this.isSetSuccess();
       boolean that_present_success = true && that.isSetSuccess();
       if (this_present_success || that_present_success) {
         if (!(this_present_success && that_present_success))
           return false;
         if (!this.success.equals(that.success))
           return false;
       }
 
       boolean this_present_nssi = true && this.isSetNssi();
       boolean that_present_nssi = true && that.isSetNssi();
       if (this_present_nssi || that_present_nssi) {
         if (!(this_present_nssi && that_present_nssi))
           return false;
         if (!this.nssi.equals(that.nssi))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(continueMultiScan_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       continueMultiScan_result typedOther = (continueMultiScan_result)other;
 
       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSuccess()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetNssi()).compareTo(typedOther.isSetNssi());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetNssi()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nssi, typedOther.nssi);
         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("continueMultiScan_result(");
       boolean first = true;
 
       sb.append("success:");
       if (this.success == null) {
         sb.append("null");
       } else {
         sb.append(this.success);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("nssi:");
       if (this.nssi == null) {
         sb.append("null");
       } else {
         sb.append(this.nssi);
       }
       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 (success != null) {
         success.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, ClassNotFoundException {
       try {
         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 continueMultiScan_resultStandardSchemeFactory implements SchemeFactory {
       public continueMultiScan_resultStandardScheme getScheme() {
         return new continueMultiScan_resultStandardScheme();
       }
     }
 
     private static class continueMultiScan_resultStandardScheme extends StandardScheme<continueMultiScan_result> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, continueMultiScan_result 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 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.success = new org.apache.accumulo.core.data.thrift.MultiScanResult();
                 struct.success.read(iprot);
                 struct.setSuccessIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // NSSI
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.nssi = new NoSuchScanIDException();
                 struct.nssi.read(iprot);
                 struct.setNssiIsSet(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, continueMultiScan_result struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.success != null) {
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           struct.success.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.nssi != null) {
           oprot.writeFieldBegin(NSSI_FIELD_DESC);
           struct.nssi.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class continueMultiScan_resultTupleSchemeFactory implements SchemeFactory {
       public continueMultiScan_resultTupleScheme getScheme() {
         return new continueMultiScan_resultTupleScheme();
       }
     }
 
     private static class continueMultiScan_resultTupleScheme extends TupleScheme<continueMultiScan_result> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, continueMultiScan_result struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetSuccess()) {
           optionals.set(0);
         }
         if (struct.isSetNssi()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetSuccess()) {
           struct.success.write(oprot);
         }
         if (struct.isSetNssi()) {
           struct.nssi.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, continueMultiScan_result struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           struct.success = new org.apache.accumulo.core.data.thrift.MultiScanResult();
           struct.success.read(iprot);
           struct.setSuccessIsSet(true);
         }
         if (incoming.get(1)) {
           struct.nssi = new NoSuchScanIDException();
           struct.nssi.read(iprot);
           struct.setNssiIsSet(true);
         }
       }
     }
 
   }
 
   public static class closeMultiScan_args implements org.apache.thrift.TBase<closeMultiScan_args, closeMultiScan_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("closeMultiScan_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField SCAN_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("scanID", org.apache.thrift.protocol.TType.I64, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new closeMultiScan_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new closeMultiScan_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public long scanID; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)2, "tinfo"),
       SCAN_ID((short)1, "scanID");
 
       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 2: // TINFO
             return TINFO;
           case 1: // SCAN_ID
             return SCAN_ID;
           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 __SCANID_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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.SCAN_ID, new org.apache.thrift.meta_data.FieldMetaData("scanID", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64          , "ScanID")));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(closeMultiScan_args.class, metaDataMap);
     }
 
     public closeMultiScan_args() {
     }
 
     public closeMultiScan_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       long scanID)
     {
       this();
       this.tinfo = tinfo;
       this.scanID = scanID;
       setScanIDIsSet(true);
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public closeMultiScan_args(closeMultiScan_args other) {
       __isset_bitfield = other.__isset_bitfield;
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       this.scanID = other.scanID;
     }
 
     public closeMultiScan_args deepCopy() {
       return new closeMultiScan_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       setScanIDIsSet(false);
       this.scanID = 0;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public closeMultiScan_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public long getScanID() {
       return this.scanID;
     }
 
     public closeMultiScan_args setScanID(long scanID) {
       this.scanID = scanID;
       setScanIDIsSet(true);
       return this;
     }
 
     public void unsetScanID() {
       __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SCANID_ISSET_ID);
     }
 
     /** Returns true if field scanID is set (has been assigned a value) and false otherwise */
     public boolean isSetScanID() {
       return EncodingUtils.testBit(__isset_bitfield, __SCANID_ISSET_ID);
     }
 
     public void setScanIDIsSet(boolean value) {
       __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SCANID_ISSET_ID, value);
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case SCAN_ID:
         if (value == null) {
           unsetScanID();
         } else {
           setScanID((Long)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case SCAN_ID:
         return Long.valueOf(getScanID());
 
       }
       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 TINFO:
         return isSetTinfo();
       case SCAN_ID:
         return isSetScanID();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof closeMultiScan_args)
         return this.equals((closeMultiScan_args)that);
       return false;
     }
 
     public boolean equals(closeMultiScan_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_scanID = true;
       boolean that_present_scanID = true;
       if (this_present_scanID || that_present_scanID) {
         if (!(this_present_scanID && that_present_scanID))
           return false;
         if (this.scanID != that.scanID)
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(closeMultiScan_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       closeMultiScan_args typedOther = (closeMultiScan_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetScanID()).compareTo(typedOther.isSetScanID());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetScanID()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scanID, typedOther.scanID);
         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("closeMultiScan_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("scanID:");
       sb.append(this.scanID);
       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 (tinfo != null) {
         tinfo.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, 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 closeMultiScan_argsStandardSchemeFactory implements SchemeFactory {
       public closeMultiScan_argsStandardScheme getScheme() {
         return new closeMultiScan_argsStandardScheme();
       }
     }
 
     private static class closeMultiScan_argsStandardScheme extends StandardScheme<closeMultiScan_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, closeMultiScan_args 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 2: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // SCAN_ID
               if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
                 struct.scanID = iprot.readI64();
                 struct.setScanIDIsSet(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, closeMultiScan_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         oprot.writeFieldBegin(SCAN_ID_FIELD_DESC);
         oprot.writeI64(struct.scanID);
         oprot.writeFieldEnd();
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class closeMultiScan_argsTupleSchemeFactory implements SchemeFactory {
       public closeMultiScan_argsTupleScheme getScheme() {
         return new closeMultiScan_argsTupleScheme();
       }
     }
 
     private static class closeMultiScan_argsTupleScheme extends TupleScheme<closeMultiScan_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, closeMultiScan_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetScanID()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetScanID()) {
           oprot.writeI64(struct.scanID);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, closeMultiScan_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.scanID = iprot.readI64();
           struct.setScanIDIsSet(true);
         }
       }
     }
 
   }
 
   public static class closeMultiScan_result implements org.apache.thrift.TBase<closeMultiScan_result, closeMultiScan_result._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("closeMultiScan_result");
 
     private static final org.apache.thrift.protocol.TField NSSI_FIELD_DESC = new org.apache.thrift.protocol.TField("nssi", org.apache.thrift.protocol.TType.STRUCT, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new closeMultiScan_resultStandardSchemeFactory());
       schemes.put(TupleScheme.class, new closeMultiScan_resultTupleSchemeFactory());
     }
 
     public NoSuchScanIDException nssi; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       NSSI((short)1, "nssi");
 
       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: // NSSI
             return NSSI;
           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
     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.NSSI, new org.apache.thrift.meta_data.FieldMetaData("nssi", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(closeMultiScan_result.class, metaDataMap);
     }
 
     public closeMultiScan_result() {
     }
 
     public closeMultiScan_result(
       NoSuchScanIDException nssi)
     {
       this();
       this.nssi = nssi;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public closeMultiScan_result(closeMultiScan_result other) {
       if (other.isSetNssi()) {
         this.nssi = new NoSuchScanIDException(other.nssi);
       }
     }
 
     public closeMultiScan_result deepCopy() {
       return new closeMultiScan_result(this);
     }
 
     @Override
     public void clear() {
       this.nssi = null;
     }
 
     public NoSuchScanIDException getNssi() {
       return this.nssi;
     }
 
     public closeMultiScan_result setNssi(NoSuchScanIDException nssi) {
       this.nssi = nssi;
       return this;
     }
 
     public void unsetNssi() {
       this.nssi = null;
     }
 
     /** Returns true if field nssi is set (has been assigned a value) and false otherwise */
     public boolean isSetNssi() {
       return this.nssi != null;
     }
 
     public void setNssiIsSet(boolean value) {
       if (!value) {
         this.nssi = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case NSSI:
         if (value == null) {
           unsetNssi();
         } else {
           setNssi((NoSuchScanIDException)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case NSSI:
         return getNssi();
 
       }
       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 NSSI:
         return isSetNssi();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof closeMultiScan_result)
         return this.equals((closeMultiScan_result)that);
       return false;
     }
 
     public boolean equals(closeMultiScan_result that) {
       if (that == null)
         return false;
 
       boolean this_present_nssi = true && this.isSetNssi();
       boolean that_present_nssi = true && that.isSetNssi();
       if (this_present_nssi || that_present_nssi) {
         if (!(this_present_nssi && that_present_nssi))
           return false;
         if (!this.nssi.equals(that.nssi))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(closeMultiScan_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       closeMultiScan_result typedOther = (closeMultiScan_result)other;
 
       lastComparison = Boolean.valueOf(isSetNssi()).compareTo(typedOther.isSetNssi());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetNssi()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nssi, typedOther.nssi);
         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("closeMultiScan_result(");
       boolean first = true;
 
       sb.append("nssi:");
       if (this.nssi == null) {
         sb.append("null");
       } else {
         sb.append(this.nssi);
       }
       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 {
         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 closeMultiScan_resultStandardSchemeFactory implements SchemeFactory {
       public closeMultiScan_resultStandardScheme getScheme() {
         return new closeMultiScan_resultStandardScheme();
       }
     }
 
     private static class closeMultiScan_resultStandardScheme extends StandardScheme<closeMultiScan_result> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, closeMultiScan_result 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: // NSSI
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.nssi = new NoSuchScanIDException();
                 struct.nssi.read(iprot);
                 struct.setNssiIsSet(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, closeMultiScan_result struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.nssi != null) {
           oprot.writeFieldBegin(NSSI_FIELD_DESC);
           struct.nssi.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class closeMultiScan_resultTupleSchemeFactory implements SchemeFactory {
       public closeMultiScan_resultTupleScheme getScheme() {
         return new closeMultiScan_resultTupleScheme();
       }
     }
 
     private static class closeMultiScan_resultTupleScheme extends TupleScheme<closeMultiScan_result> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, closeMultiScan_result struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetNssi()) {
           optionals.set(0);
         }
         oprot.writeBitSet(optionals, 1);
         if (struct.isSetNssi()) {
           struct.nssi.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, closeMultiScan_result struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(1);
         if (incoming.get(0)) {
           struct.nssi = new NoSuchScanIDException();
           struct.nssi.read(iprot);
           struct.setNssiIsSet(true);
         }
       }
     }
 
   }
 
   public static class startUpdate_args implements org.apache.thrift.TBase<startUpdate_args, startUpdate_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("startUpdate_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new startUpdate_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new startUpdate_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)2, "tinfo"),
       CREDENTIAL((short)1, "credential");
 
       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 2: // TINFO
             return TINFO;
           case 1: // CREDENTIAL
             return CREDENTIAL;
           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
     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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(startUpdate_args.class, metaDataMap);
     }
 
     public startUpdate_args() {
     }
 
     public startUpdate_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public startUpdate_args(startUpdate_args other) {
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
     }
 
     public startUpdate_args deepCopy() {
       return new startUpdate_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public startUpdate_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public startUpdate_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof startUpdate_args)
         return this.equals((startUpdate_args)that);
       return false;
     }
 
     public boolean equals(startUpdate_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(startUpdate_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       startUpdate_args typedOther = (startUpdate_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         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("startUpdate_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.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, ClassNotFoundException {
       try {
         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 startUpdate_argsStandardSchemeFactory implements SchemeFactory {
       public startUpdate_argsStandardScheme getScheme() {
         return new startUpdate_argsStandardScheme();
       }
     }
 
     private static class startUpdate_argsStandardScheme extends StandardScheme<startUpdate_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, startUpdate_args 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 2: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(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, startUpdate_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class startUpdate_argsTupleSchemeFactory implements SchemeFactory {
       public startUpdate_argsTupleScheme getScheme() {
         return new startUpdate_argsTupleScheme();
       }
     }
 
     private static class startUpdate_argsTupleScheme extends TupleScheme<startUpdate_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, startUpdate_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, startUpdate_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
       }
     }
 
   }
 
   public static class startUpdate_result implements org.apache.thrift.TBase<startUpdate_result, startUpdate_result._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("startUpdate_result");
 
     private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.I64, (short)0);
     private static final org.apache.thrift.protocol.TField SEC_FIELD_DESC = new org.apache.thrift.protocol.TField("sec", org.apache.thrift.protocol.TType.STRUCT, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new startUpdate_resultStandardSchemeFactory());
       schemes.put(TupleScheme.class, new startUpdate_resultTupleSchemeFactory());
     }
 
     public long success; // required
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException sec; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       SUCCESS((short)0, "success"),
       SEC((short)1, "sec");
 
       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 0: // SUCCESS
             return SUCCESS;
           case 1: // SEC
             return SEC;
           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 __SUCCESS_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.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64          , "UpdateID")));
       tmpMap.put(_Fields.SEC, new org.apache.thrift.meta_data.FieldMetaData("sec", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(startUpdate_result.class, metaDataMap);
     }
 
     public startUpdate_result() {
     }
 
     public startUpdate_result(
       long success,
       org.apache.accumulo.core.security.thrift.ThriftSecurityException sec)
     {
       this();
       this.success = success;
       setSuccessIsSet(true);
       this.sec = sec;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public startUpdate_result(startUpdate_result other) {
       __isset_bitfield = other.__isset_bitfield;
       this.success = other.success;
       if (other.isSetSec()) {
         this.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException(other.sec);
       }
     }
 
     public startUpdate_result deepCopy() {
       return new startUpdate_result(this);
     }
 
     @Override
     public void clear() {
       setSuccessIsSet(false);
       this.success = 0;
       this.sec = null;
     }
 
     public long getSuccess() {
       return this.success;
     }
 
     public startUpdate_result setSuccess(long success) {
       this.success = success;
       setSuccessIsSet(true);
       return this;
     }
 
     public void unsetSuccess() {
       __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
     }
 
     /** Returns true if field success is set (has been assigned a value) and false otherwise */
     public boolean isSetSuccess() {
       return EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
     }
 
     public void setSuccessIsSet(boolean value) {
       __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
     }
 
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException getSec() {
       return this.sec;
     }
 
     public startUpdate_result setSec(org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
       this.sec = sec;
       return this;
     }
 
     public void unsetSec() {
       this.sec = null;
     }
 
     /** Returns true if field sec is set (has been assigned a value) and false otherwise */
     public boolean isSetSec() {
       return this.sec != null;
     }
 
     public void setSecIsSet(boolean value) {
       if (!value) {
         this.sec = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
           setSuccess((Long)value);
         }
         break;
 
       case SEC:
         if (value == null) {
           unsetSec();
         } else {
           setSec((org.apache.accumulo.core.security.thrift.ThriftSecurityException)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
         return Long.valueOf(getSuccess());
 
       case SEC:
         return getSec();
 
       }
       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 SUCCESS:
         return isSetSuccess();
       case SEC:
         return isSetSec();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof startUpdate_result)
         return this.equals((startUpdate_result)that);
       return false;
     }
 
     public boolean equals(startUpdate_result that) {
       if (that == null)
         return false;
 
       boolean this_present_success = true;
       boolean that_present_success = true;
       if (this_present_success || that_present_success) {
         if (!(this_present_success && that_present_success))
           return false;
         if (this.success != that.success)
           return false;
       }
 
       boolean this_present_sec = true && this.isSetSec();
       boolean that_present_sec = true && that.isSetSec();
       if (this_present_sec || that_present_sec) {
         if (!(this_present_sec && that_present_sec))
           return false;
         if (!this.sec.equals(that.sec))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(startUpdate_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       startUpdate_result typedOther = (startUpdate_result)other;
 
       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSuccess()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetSec()).compareTo(typedOther.isSetSec());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSec()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sec, typedOther.sec);
         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("startUpdate_result(");
       boolean first = true;
 
       sb.append("success:");
       sb.append(this.success);
       first = false;
       if (!first) sb.append(", ");
       sb.append("sec:");
       if (this.sec == null) {
         sb.append("null");
       } else {
         sb.append(this.sec);
       }
       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 startUpdate_resultStandardSchemeFactory implements SchemeFactory {
       public startUpdate_resultStandardScheme getScheme() {
         return new startUpdate_resultStandardScheme();
       }
     }
 
     private static class startUpdate_resultStandardScheme extends StandardScheme<startUpdate_result> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, startUpdate_result 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 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
                 struct.success = iprot.readI64();
                 struct.setSuccessIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // SEC
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
                 struct.sec.read(iprot);
                 struct.setSecIsSet(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, startUpdate_result struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.isSetSuccess()) {
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           oprot.writeI64(struct.success);
           oprot.writeFieldEnd();
         }
         if (struct.sec != null) {
           oprot.writeFieldBegin(SEC_FIELD_DESC);
           struct.sec.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class startUpdate_resultTupleSchemeFactory implements SchemeFactory {
       public startUpdate_resultTupleScheme getScheme() {
         return new startUpdate_resultTupleScheme();
       }
     }
 
     private static class startUpdate_resultTupleScheme extends TupleScheme<startUpdate_result> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, startUpdate_result struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetSuccess()) {
           optionals.set(0);
         }
         if (struct.isSetSec()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetSuccess()) {
           oprot.writeI64(struct.success);
         }
         if (struct.isSetSec()) {
           struct.sec.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, startUpdate_result struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           struct.success = iprot.readI64();
           struct.setSuccessIsSet(true);
         }
         if (incoming.get(1)) {
           struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
           struct.sec.read(iprot);
           struct.setSecIsSet(true);
         }
       }
     }
 
   }
 
   public static class applyUpdates_args implements org.apache.thrift.TBase<applyUpdates_args, applyUpdates_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("applyUpdates_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField UPDATE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("updateID", org.apache.thrift.protocol.TType.I64, (short)2);
     private static final org.apache.thrift.protocol.TField KEY_EXTENT_FIELD_DESC = new org.apache.thrift.protocol.TField("keyExtent", org.apache.thrift.protocol.TType.STRUCT, (short)3);
     private static final org.apache.thrift.protocol.TField MUTATIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("mutations", org.apache.thrift.protocol.TType.LIST, (short)4);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new applyUpdates_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new applyUpdates_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public long updateID; // required
     public org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent; // required
     public List<org.apache.accumulo.core.data.thrift.TMutation> mutations; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)1, "tinfo"),
       UPDATE_ID((short)2, "updateID"),
       KEY_EXTENT((short)3, "keyExtent"),
       MUTATIONS((short)4, "mutations");
 
       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: // TINFO
             return TINFO;
           case 2: // UPDATE_ID
             return UPDATE_ID;
           case 3: // KEY_EXTENT
             return KEY_EXTENT;
           case 4: // MUTATIONS
             return MUTATIONS;
           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 __UPDATEID_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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.UPDATE_ID, new org.apache.thrift.meta_data.FieldMetaData("updateID", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64          , "UpdateID")));
       tmpMap.put(_Fields.KEY_EXTENT, new org.apache.thrift.meta_data.FieldMetaData("keyExtent", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.data.thrift.TKeyExtent.class)));
       tmpMap.put(_Fields.MUTATIONS, new org.apache.thrift.meta_data.FieldMetaData("mutations", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           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, org.apache.accumulo.core.data.thrift.TMutation.class))));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(applyUpdates_args.class, metaDataMap);
     }
 
     public applyUpdates_args() {
     }
 
     public applyUpdates_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       long updateID,
       org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent,
       List<org.apache.accumulo.core.data.thrift.TMutation> mutations)
     {
       this();
       this.tinfo = tinfo;
       this.updateID = updateID;
       setUpdateIDIsSet(true);
       this.keyExtent = keyExtent;
       this.mutations = mutations;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public applyUpdates_args(applyUpdates_args other) {
       __isset_bitfield = other.__isset_bitfield;
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       this.updateID = other.updateID;
       if (other.isSetKeyExtent()) {
         this.keyExtent = new org.apache.accumulo.core.data.thrift.TKeyExtent(other.keyExtent);
       }
       if (other.isSetMutations()) {
         List<org.apache.accumulo.core.data.thrift.TMutation> __this__mutations = new ArrayList<org.apache.accumulo.core.data.thrift.TMutation>();
         for (org.apache.accumulo.core.data.thrift.TMutation other_element : other.mutations) {
           __this__mutations.add(new org.apache.accumulo.core.data.thrift.TMutation(other_element));
         }
         this.mutations = __this__mutations;
       }
     }
 
     public applyUpdates_args deepCopy() {
       return new applyUpdates_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       setUpdateIDIsSet(false);
       this.updateID = 0;
       this.keyExtent = null;
       this.mutations = null;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public applyUpdates_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public long getUpdateID() {
       return this.updateID;
     }
 
     public applyUpdates_args setUpdateID(long updateID) {
       this.updateID = updateID;
       setUpdateIDIsSet(true);
       return this;
     }
 
     public void unsetUpdateID() {
       __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __UPDATEID_ISSET_ID);
     }
 
     /** Returns true if field updateID is set (has been assigned a value) and false otherwise */
     public boolean isSetUpdateID() {
       return EncodingUtils.testBit(__isset_bitfield, __UPDATEID_ISSET_ID);
     }
 
     public void setUpdateIDIsSet(boolean value) {
       __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __UPDATEID_ISSET_ID, value);
     }
 
     public org.apache.accumulo.core.data.thrift.TKeyExtent getKeyExtent() {
       return this.keyExtent;
     }
 
     public applyUpdates_args setKeyExtent(org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent) {
       this.keyExtent = keyExtent;
       return this;
     }
 
     public void unsetKeyExtent() {
       this.keyExtent = null;
     }
 
     /** Returns true if field keyExtent is set (has been assigned a value) and false otherwise */
     public boolean isSetKeyExtent() {
       return this.keyExtent != null;
     }
 
     public void setKeyExtentIsSet(boolean value) {
       if (!value) {
         this.keyExtent = null;
       }
     }
 
     public int getMutationsSize() {
       return (this.mutations == null) ? 0 : this.mutations.size();
     }
 
     public java.util.Iterator<org.apache.accumulo.core.data.thrift.TMutation> getMutationsIterator() {
       return (this.mutations == null) ? null : this.mutations.iterator();
     }
 
     public void addToMutations(org.apache.accumulo.core.data.thrift.TMutation elem) {
       if (this.mutations == null) {
         this.mutations = new ArrayList<org.apache.accumulo.core.data.thrift.TMutation>();
       }
       this.mutations.add(elem);
     }
 
     public List<org.apache.accumulo.core.data.thrift.TMutation> getMutations() {
       return this.mutations;
     }
 
     public applyUpdates_args setMutations(List<org.apache.accumulo.core.data.thrift.TMutation> mutations) {
       this.mutations = mutations;
       return this;
     }
 
     public void unsetMutations() {
       this.mutations = null;
     }
 
     /** Returns true if field mutations is set (has been assigned a value) and false otherwise */
     public boolean isSetMutations() {
       return this.mutations != null;
     }
 
     public void setMutationsIsSet(boolean value) {
       if (!value) {
         this.mutations = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case UPDATE_ID:
         if (value == null) {
           unsetUpdateID();
         } else {
           setUpdateID((Long)value);
         }
         break;
 
       case KEY_EXTENT:
         if (value == null) {
           unsetKeyExtent();
         } else {
           setKeyExtent((org.apache.accumulo.core.data.thrift.TKeyExtent)value);
         }
         break;
 
       case MUTATIONS:
         if (value == null) {
           unsetMutations();
         } else {
           setMutations((List<org.apache.accumulo.core.data.thrift.TMutation>)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case UPDATE_ID:
         return Long.valueOf(getUpdateID());
 
       case KEY_EXTENT:
         return getKeyExtent();
 
       case MUTATIONS:
         return getMutations();
 
       }
       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 TINFO:
         return isSetTinfo();
       case UPDATE_ID:
         return isSetUpdateID();
       case KEY_EXTENT:
         return isSetKeyExtent();
       case MUTATIONS:
         return isSetMutations();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof applyUpdates_args)
         return this.equals((applyUpdates_args)that);
       return false;
     }
 
     public boolean equals(applyUpdates_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_updateID = true;
       boolean that_present_updateID = true;
       if (this_present_updateID || that_present_updateID) {
         if (!(this_present_updateID && that_present_updateID))
           return false;
         if (this.updateID != that.updateID)
           return false;
       }
 
       boolean this_present_keyExtent = true && this.isSetKeyExtent();
       boolean that_present_keyExtent = true && that.isSetKeyExtent();
       if (this_present_keyExtent || that_present_keyExtent) {
         if (!(this_present_keyExtent && that_present_keyExtent))
           return false;
         if (!this.keyExtent.equals(that.keyExtent))
           return false;
       }
 
       boolean this_present_mutations = true && this.isSetMutations();
       boolean that_present_mutations = true && that.isSetMutations();
       if (this_present_mutations || that_present_mutations) {
         if (!(this_present_mutations && that_present_mutations))
           return false;
         if (!this.mutations.equals(that.mutations))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(applyUpdates_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       applyUpdates_args typedOther = (applyUpdates_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetUpdateID()).compareTo(typedOther.isSetUpdateID());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetUpdateID()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.updateID, typedOther.updateID);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetKeyExtent()).compareTo(typedOther.isSetKeyExtent());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetKeyExtent()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.keyExtent, typedOther.keyExtent);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetMutations()).compareTo(typedOther.isSetMutations());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetMutations()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.mutations, typedOther.mutations);
         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("applyUpdates_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("updateID:");
       sb.append(this.updateID);
       first = false;
       if (!first) sb.append(", ");
       sb.append("keyExtent:");
       if (this.keyExtent == null) {
         sb.append("null");
       } else {
         sb.append(this.keyExtent);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("mutations:");
       if (this.mutations == null) {
         sb.append("null");
       } else {
         sb.append(this.mutations);
       }
       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 (tinfo != null) {
         tinfo.validate();
       }
       if (keyExtent != null) {
         keyExtent.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, 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 applyUpdates_argsStandardSchemeFactory implements SchemeFactory {
       public applyUpdates_argsStandardScheme getScheme() {
         return new applyUpdates_argsStandardScheme();
       }
     }
 
     private static class applyUpdates_argsStandardScheme extends StandardScheme<applyUpdates_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, applyUpdates_args 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: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // UPDATE_ID
               if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
                 struct.updateID = iprot.readI64();
                 struct.setUpdateIDIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 3: // KEY_EXTENT
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.keyExtent = new org.apache.accumulo.core.data.thrift.TKeyExtent();
                 struct.keyExtent.read(iprot);
                 struct.setKeyExtentIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 4: // MUTATIONS
               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                 {
                   org.apache.thrift.protocol.TList _list212 = iprot.readListBegin();
                   struct.mutations = new ArrayList<org.apache.accumulo.core.data.thrift.TMutation>(_list212.size);
                   for (int _i213 = 0; _i213 < _list212.size; ++_i213)
                   {
                     org.apache.accumulo.core.data.thrift.TMutation _elem214; // required
                     _elem214 = new org.apache.accumulo.core.data.thrift.TMutation();
                     _elem214.read(iprot);
                     struct.mutations.add(_elem214);
                   }
                   iprot.readListEnd();
                 }
                 struct.setMutationsIsSet(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, applyUpdates_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldBegin(UPDATE_ID_FIELD_DESC);
         oprot.writeI64(struct.updateID);
         oprot.writeFieldEnd();
         if (struct.keyExtent != null) {
           oprot.writeFieldBegin(KEY_EXTENT_FIELD_DESC);
           struct.keyExtent.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.mutations != null) {
           oprot.writeFieldBegin(MUTATIONS_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.mutations.size()));
             for (org.apache.accumulo.core.data.thrift.TMutation _iter215 : struct.mutations)
             {
               _iter215.write(oprot);
             }
             oprot.writeListEnd();
           }
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class applyUpdates_argsTupleSchemeFactory implements SchemeFactory {
       public applyUpdates_argsTupleScheme getScheme() {
         return new applyUpdates_argsTupleScheme();
       }
     }
 
     private static class applyUpdates_argsTupleScheme extends TupleScheme<applyUpdates_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, applyUpdates_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetUpdateID()) {
           optionals.set(1);
         }
         if (struct.isSetKeyExtent()) {
           optionals.set(2);
         }
         if (struct.isSetMutations()) {
           optionals.set(3);
         }
         oprot.writeBitSet(optionals, 4);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetUpdateID()) {
           oprot.writeI64(struct.updateID);
         }
         if (struct.isSetKeyExtent()) {
           struct.keyExtent.write(oprot);
         }
         if (struct.isSetMutations()) {
           {
             oprot.writeI32(struct.mutations.size());
             for (org.apache.accumulo.core.data.thrift.TMutation _iter216 : struct.mutations)
             {
               _iter216.write(oprot);
             }
           }
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, applyUpdates_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(4);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.updateID = iprot.readI64();
           struct.setUpdateIDIsSet(true);
         }
         if (incoming.get(2)) {
           struct.keyExtent = new org.apache.accumulo.core.data.thrift.TKeyExtent();
           struct.keyExtent.read(iprot);
           struct.setKeyExtentIsSet(true);
         }
         if (incoming.get(3)) {
           {
             org.apache.thrift.protocol.TList _list217 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
             struct.mutations = new ArrayList<org.apache.accumulo.core.data.thrift.TMutation>(_list217.size);
             for (int _i218 = 0; _i218 < _list217.size; ++_i218)
             {
               org.apache.accumulo.core.data.thrift.TMutation _elem219; // required
               _elem219 = new org.apache.accumulo.core.data.thrift.TMutation();
               _elem219.read(iprot);
               struct.mutations.add(_elem219);
             }
           }
           struct.setMutationsIsSet(true);
         }
       }
     }
 
   }
 
   public static class closeUpdate_args implements org.apache.thrift.TBase<closeUpdate_args, closeUpdate_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("closeUpdate_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField UPDATE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("updateID", org.apache.thrift.protocol.TType.I64, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new closeUpdate_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new closeUpdate_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public long updateID; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)2, "tinfo"),
       UPDATE_ID((short)1, "updateID");
 
       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 2: // TINFO
             return TINFO;
           case 1: // UPDATE_ID
             return UPDATE_ID;
           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 __UPDATEID_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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.UPDATE_ID, new org.apache.thrift.meta_data.FieldMetaData("updateID", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64          , "UpdateID")));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(closeUpdate_args.class, metaDataMap);
     }
 
     public closeUpdate_args() {
     }
 
     public closeUpdate_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       long updateID)
     {
       this();
       this.tinfo = tinfo;
       this.updateID = updateID;
       setUpdateIDIsSet(true);
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public closeUpdate_args(closeUpdate_args other) {
       __isset_bitfield = other.__isset_bitfield;
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       this.updateID = other.updateID;
     }
 
     public closeUpdate_args deepCopy() {
       return new closeUpdate_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       setUpdateIDIsSet(false);
       this.updateID = 0;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public closeUpdate_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public long getUpdateID() {
       return this.updateID;
     }
 
     public closeUpdate_args setUpdateID(long updateID) {
       this.updateID = updateID;
       setUpdateIDIsSet(true);
       return this;
     }
 
     public void unsetUpdateID() {
       __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __UPDATEID_ISSET_ID);
     }
 
     /** Returns true if field updateID is set (has been assigned a value) and false otherwise */
     public boolean isSetUpdateID() {
       return EncodingUtils.testBit(__isset_bitfield, __UPDATEID_ISSET_ID);
     }
 
     public void setUpdateIDIsSet(boolean value) {
       __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __UPDATEID_ISSET_ID, value);
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case UPDATE_ID:
         if (value == null) {
           unsetUpdateID();
         } else {
           setUpdateID((Long)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case UPDATE_ID:
         return Long.valueOf(getUpdateID());
 
       }
       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 TINFO:
         return isSetTinfo();
       case UPDATE_ID:
         return isSetUpdateID();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof closeUpdate_args)
         return this.equals((closeUpdate_args)that);
       return false;
     }
 
     public boolean equals(closeUpdate_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_updateID = true;
       boolean that_present_updateID = true;
       if (this_present_updateID || that_present_updateID) {
         if (!(this_present_updateID && that_present_updateID))
           return false;
         if (this.updateID != that.updateID)
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(closeUpdate_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       closeUpdate_args typedOther = (closeUpdate_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetUpdateID()).compareTo(typedOther.isSetUpdateID());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetUpdateID()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.updateID, typedOther.updateID);
         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("closeUpdate_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("updateID:");
       sb.append(this.updateID);
       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 (tinfo != null) {
         tinfo.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, 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 closeUpdate_argsStandardSchemeFactory implements SchemeFactory {
       public closeUpdate_argsStandardScheme getScheme() {
         return new closeUpdate_argsStandardScheme();
       }
     }
 
     private static class closeUpdate_argsStandardScheme extends StandardScheme<closeUpdate_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, closeUpdate_args 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 2: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // UPDATE_ID
               if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
                 struct.updateID = iprot.readI64();
                 struct.setUpdateIDIsSet(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, closeUpdate_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         oprot.writeFieldBegin(UPDATE_ID_FIELD_DESC);
         oprot.writeI64(struct.updateID);
         oprot.writeFieldEnd();
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class closeUpdate_argsTupleSchemeFactory implements SchemeFactory {
       public closeUpdate_argsTupleScheme getScheme() {
         return new closeUpdate_argsTupleScheme();
       }
     }
 
     private static class closeUpdate_argsTupleScheme extends TupleScheme<closeUpdate_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, closeUpdate_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetUpdateID()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetUpdateID()) {
           oprot.writeI64(struct.updateID);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, closeUpdate_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.updateID = iprot.readI64();
           struct.setUpdateIDIsSet(true);
         }
       }
     }
 
   }
 
   public static class closeUpdate_result implements org.apache.thrift.TBase<closeUpdate_result, closeUpdate_result._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("closeUpdate_result");
 
     private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
     private static final org.apache.thrift.protocol.TField NSSI_FIELD_DESC = new org.apache.thrift.protocol.TField("nssi", org.apache.thrift.protocol.TType.STRUCT, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new closeUpdate_resultStandardSchemeFactory());
       schemes.put(TupleScheme.class, new closeUpdate_resultTupleSchemeFactory());
     }
 
     public org.apache.accumulo.core.data.thrift.UpdateErrors success; // required
     public NoSuchScanIDException nssi; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       SUCCESS((short)0, "success"),
       NSSI((short)1, "nssi");
 
       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 0: // SUCCESS
             return SUCCESS;
           case 1: // NSSI
             return NSSI;
           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
     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.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.data.thrift.UpdateErrors.class)));
       tmpMap.put(_Fields.NSSI, new org.apache.thrift.meta_data.FieldMetaData("nssi", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(closeUpdate_result.class, metaDataMap);
     }
 
     public closeUpdate_result() {
     }
 
     public closeUpdate_result(
       org.apache.accumulo.core.data.thrift.UpdateErrors success,
       NoSuchScanIDException nssi)
     {
       this();
       this.success = success;
       this.nssi = nssi;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public closeUpdate_result(closeUpdate_result other) {
       if (other.isSetSuccess()) {
         this.success = new org.apache.accumulo.core.data.thrift.UpdateErrors(other.success);
       }
       if (other.isSetNssi()) {
         this.nssi = new NoSuchScanIDException(other.nssi);
       }
     }
 
     public closeUpdate_result deepCopy() {
       return new closeUpdate_result(this);
     }
 
     @Override
     public void clear() {
       this.success = null;
       this.nssi = null;
     }
 
     public org.apache.accumulo.core.data.thrift.UpdateErrors getSuccess() {
       return this.success;
     }
 
     public closeUpdate_result setSuccess(org.apache.accumulo.core.data.thrift.UpdateErrors success) {
       this.success = success;
       return this;
     }
 
     public void unsetSuccess() {
       this.success = null;
     }
 
     /** Returns true if field success is set (has been assigned a value) and false otherwise */
     public boolean isSetSuccess() {
       return this.success != null;
     }
 
     public void setSuccessIsSet(boolean value) {
       if (!value) {
         this.success = null;
       }
     }
 
     public NoSuchScanIDException getNssi() {
       return this.nssi;
     }
 
     public closeUpdate_result setNssi(NoSuchScanIDException nssi) {
       this.nssi = nssi;
       return this;
     }
 
     public void unsetNssi() {
       this.nssi = null;
     }
 
     /** Returns true if field nssi is set (has been assigned a value) and false otherwise */
     public boolean isSetNssi() {
       return this.nssi != null;
     }
 
     public void setNssiIsSet(boolean value) {
       if (!value) {
         this.nssi = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
           setSuccess((org.apache.accumulo.core.data.thrift.UpdateErrors)value);
         }
         break;
 
       case NSSI:
         if (value == null) {
           unsetNssi();
         } else {
           setNssi((NoSuchScanIDException)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
         return getSuccess();
 
       case NSSI:
         return getNssi();
 
       }
       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 SUCCESS:
         return isSetSuccess();
       case NSSI:
         return isSetNssi();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof closeUpdate_result)
         return this.equals((closeUpdate_result)that);
       return false;
     }
 
     public boolean equals(closeUpdate_result that) {
       if (that == null)
         return false;
 
       boolean this_present_success = true && this.isSetSuccess();
       boolean that_present_success = true && that.isSetSuccess();
       if (this_present_success || that_present_success) {
         if (!(this_present_success && that_present_success))
           return false;
         if (!this.success.equals(that.success))
           return false;
       }
 
       boolean this_present_nssi = true && this.isSetNssi();
       boolean that_present_nssi = true && that.isSetNssi();
       if (this_present_nssi || that_present_nssi) {
         if (!(this_present_nssi && that_present_nssi))
           return false;
         if (!this.nssi.equals(that.nssi))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(closeUpdate_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       closeUpdate_result typedOther = (closeUpdate_result)other;
 
       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSuccess()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetNssi()).compareTo(typedOther.isSetNssi());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetNssi()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nssi, typedOther.nssi);
         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("closeUpdate_result(");
       boolean first = true;
 
       sb.append("success:");
       if (this.success == null) {
         sb.append("null");
       } else {
         sb.append(this.success);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("nssi:");
       if (this.nssi == null) {
         sb.append("null");
       } else {
         sb.append(this.nssi);
       }
       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 (success != null) {
         success.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, ClassNotFoundException {
       try {
         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 closeUpdate_resultStandardSchemeFactory implements SchemeFactory {
       public closeUpdate_resultStandardScheme getScheme() {
         return new closeUpdate_resultStandardScheme();
       }
     }
 
     private static class closeUpdate_resultStandardScheme extends StandardScheme<closeUpdate_result> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, closeUpdate_result 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 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.success = new org.apache.accumulo.core.data.thrift.UpdateErrors();
                 struct.success.read(iprot);
                 struct.setSuccessIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // NSSI
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.nssi = new NoSuchScanIDException();
                 struct.nssi.read(iprot);
                 struct.setNssiIsSet(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, closeUpdate_result struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.success != null) {
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           struct.success.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.nssi != null) {
           oprot.writeFieldBegin(NSSI_FIELD_DESC);
           struct.nssi.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class closeUpdate_resultTupleSchemeFactory implements SchemeFactory {
       public closeUpdate_resultTupleScheme getScheme() {
         return new closeUpdate_resultTupleScheme();
       }
     }
 
     private static class closeUpdate_resultTupleScheme extends TupleScheme<closeUpdate_result> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, closeUpdate_result struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetSuccess()) {
           optionals.set(0);
         }
         if (struct.isSetNssi()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetSuccess()) {
           struct.success.write(oprot);
         }
         if (struct.isSetNssi()) {
           struct.nssi.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, closeUpdate_result struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           struct.success = new org.apache.accumulo.core.data.thrift.UpdateErrors();
           struct.success.read(iprot);
           struct.setSuccessIsSet(true);
         }
         if (incoming.get(1)) {
           struct.nssi = new NoSuchScanIDException();
           struct.nssi.read(iprot);
           struct.setNssiIsSet(true);
         }
       }
     }
 
   }
 
   public static class update_args implements org.apache.thrift.TBase<update_args, update_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("update_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)4);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField KEY_EXTENT_FIELD_DESC = new org.apache.thrift.protocol.TField("keyExtent", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField MUTATION_FIELD_DESC = new org.apache.thrift.protocol.TField("mutation", org.apache.thrift.protocol.TType.STRUCT, (short)3);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new update_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new update_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
     public org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent; // required
     public org.apache.accumulo.core.data.thrift.TMutation mutation; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)4, "tinfo"),
       CREDENTIAL((short)1, "credential"),
       KEY_EXTENT((short)2, "keyExtent"),
       MUTATION((short)3, "mutation");
 
       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 4: // TINFO
             return TINFO;
           case 1: // CREDENTIAL
             return CREDENTIAL;
           case 2: // KEY_EXTENT
             return KEY_EXTENT;
           case 3: // MUTATION
             return MUTATION;
           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
     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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       tmpMap.put(_Fields.KEY_EXTENT, new org.apache.thrift.meta_data.FieldMetaData("keyExtent", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.data.thrift.TKeyExtent.class)));
       tmpMap.put(_Fields.MUTATION, new org.apache.thrift.meta_data.FieldMetaData("mutation", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.data.thrift.TMutation.class)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(update_args.class, metaDataMap);
     }
 
     public update_args() {
     }
 
     public update_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential,
       org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent,
       org.apache.accumulo.core.data.thrift.TMutation mutation)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
       this.keyExtent = keyExtent;
       this.mutation = mutation;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public update_args(update_args other) {
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
       if (other.isSetKeyExtent()) {
         this.keyExtent = new org.apache.accumulo.core.data.thrift.TKeyExtent(other.keyExtent);
       }
       if (other.isSetMutation()) {
         this.mutation = new org.apache.accumulo.core.data.thrift.TMutation(other.mutation);
       }
     }
 
     public update_args deepCopy() {
       return new update_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
       this.keyExtent = null;
       this.mutation = null;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public update_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public update_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public org.apache.accumulo.core.data.thrift.TKeyExtent getKeyExtent() {
       return this.keyExtent;
     }
 
     public update_args setKeyExtent(org.apache.accumulo.core.data.thrift.TKeyExtent keyExtent) {
       this.keyExtent = keyExtent;
       return this;
     }
 
     public void unsetKeyExtent() {
       this.keyExtent = null;
     }
 
     /** Returns true if field keyExtent is set (has been assigned a value) and false otherwise */
     public boolean isSetKeyExtent() {
       return this.keyExtent != null;
     }
 
     public void setKeyExtentIsSet(boolean value) {
       if (!value) {
         this.keyExtent = null;
       }
     }
 
     public org.apache.accumulo.core.data.thrift.TMutation getMutation() {
       return this.mutation;
     }
 
     public update_args setMutation(org.apache.accumulo.core.data.thrift.TMutation mutation) {
       this.mutation = mutation;
       return this;
     }
 
     public void unsetMutation() {
       this.mutation = null;
     }
 
     /** Returns true if field mutation is set (has been assigned a value) and false otherwise */
     public boolean isSetMutation() {
       return this.mutation != null;
     }
 
     public void setMutationIsSet(boolean value) {
       if (!value) {
         this.mutation = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       case KEY_EXTENT:
         if (value == null) {
           unsetKeyExtent();
         } else {
           setKeyExtent((org.apache.accumulo.core.data.thrift.TKeyExtent)value);
         }
         break;
 
       case MUTATION:
         if (value == null) {
           unsetMutation();
         } else {
           setMutation((org.apache.accumulo.core.data.thrift.TMutation)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       case KEY_EXTENT:
         return getKeyExtent();
 
       case MUTATION:
         return getMutation();
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       case KEY_EXTENT:
         return isSetKeyExtent();
       case MUTATION:
         return isSetMutation();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof update_args)
         return this.equals((update_args)that);
       return false;
     }
 
     public boolean equals(update_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       boolean this_present_keyExtent = true && this.isSetKeyExtent();
       boolean that_present_keyExtent = true && that.isSetKeyExtent();
       if (this_present_keyExtent || that_present_keyExtent) {
         if (!(this_present_keyExtent && that_present_keyExtent))
           return false;
         if (!this.keyExtent.equals(that.keyExtent))
           return false;
       }
 
       boolean this_present_mutation = true && this.isSetMutation();
       boolean that_present_mutation = true && that.isSetMutation();
       if (this_present_mutation || that_present_mutation) {
         if (!(this_present_mutation && that_present_mutation))
           return false;
         if (!this.mutation.equals(that.mutation))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(update_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       update_args typedOther = (update_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetKeyExtent()).compareTo(typedOther.isSetKeyExtent());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetKeyExtent()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.keyExtent, typedOther.keyExtent);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetMutation()).compareTo(typedOther.isSetMutation());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetMutation()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.mutation, typedOther.mutation);
         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("update_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("keyExtent:");
       if (this.keyExtent == null) {
         sb.append("null");
       } else {
         sb.append(this.keyExtent);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("mutation:");
       if (this.mutation == null) {
         sb.append("null");
       } else {
         sb.append(this.mutation);
       }
       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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.validate();
       }
       if (keyExtent != null) {
         keyExtent.validate();
       }
       if (mutation != null) {
         mutation.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, ClassNotFoundException {
       try {
         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 update_argsStandardSchemeFactory implements SchemeFactory {
       public update_argsStandardScheme getScheme() {
         return new update_argsStandardScheme();
       }
     }
 
     private static class update_argsStandardScheme extends StandardScheme<update_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, update_args 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 4: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // KEY_EXTENT
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.keyExtent = new org.apache.accumulo.core.data.thrift.TKeyExtent();
                 struct.keyExtent.read(iprot);
                 struct.setKeyExtentIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 3: // MUTATION
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.mutation = new org.apache.accumulo.core.data.thrift.TMutation();
                 struct.mutation.read(iprot);
                 struct.setMutationIsSet(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, update_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.keyExtent != null) {
           oprot.writeFieldBegin(KEY_EXTENT_FIELD_DESC);
           struct.keyExtent.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.mutation != null) {
           oprot.writeFieldBegin(MUTATION_FIELD_DESC);
           struct.mutation.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class update_argsTupleSchemeFactory implements SchemeFactory {
       public update_argsTupleScheme getScheme() {
         return new update_argsTupleScheme();
       }
     }
 
     private static class update_argsTupleScheme extends TupleScheme<update_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, update_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         if (struct.isSetKeyExtent()) {
           optionals.set(2);
         }
         if (struct.isSetMutation()) {
           optionals.set(3);
         }
         oprot.writeBitSet(optionals, 4);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
         if (struct.isSetKeyExtent()) {
           struct.keyExtent.write(oprot);
         }
         if (struct.isSetMutation()) {
           struct.mutation.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, update_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(4);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
         if (incoming.get(2)) {
           struct.keyExtent = new org.apache.accumulo.core.data.thrift.TKeyExtent();
           struct.keyExtent.read(iprot);
           struct.setKeyExtentIsSet(true);
         }
         if (incoming.get(3)) {
           struct.mutation = new org.apache.accumulo.core.data.thrift.TMutation();
           struct.mutation.read(iprot);
           struct.setMutationIsSet(true);
         }
       }
     }
 
   }
 
   public static class update_result implements org.apache.thrift.TBase<update_result, update_result._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("update_result");
 
     private static final org.apache.thrift.protocol.TField SEC_FIELD_DESC = new org.apache.thrift.protocol.TField("sec", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField NSTE_FIELD_DESC = new org.apache.thrift.protocol.TField("nste", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField CVE_FIELD_DESC = new org.apache.thrift.protocol.TField("cve", org.apache.thrift.protocol.TType.STRUCT, (short)3);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new update_resultStandardSchemeFactory());
       schemes.put(TupleScheme.class, new update_resultTupleSchemeFactory());
     }
 
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException sec; // required
     public NotServingTabletException nste; // required
     public ConstraintViolationException cve; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       SEC((short)1, "sec"),
       NSTE((short)2, "nste"),
       CVE((short)3, "cve");
 
       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: // SEC
             return SEC;
           case 2: // NSTE
             return NSTE;
           case 3: // CVE
             return CVE;
           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
     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.SEC, new org.apache.thrift.meta_data.FieldMetaData("sec", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       tmpMap.put(_Fields.NSTE, new org.apache.thrift.meta_data.FieldMetaData("nste", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       tmpMap.put(_Fields.CVE, new org.apache.thrift.meta_data.FieldMetaData("cve", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(update_result.class, metaDataMap);
     }
 
     public update_result() {
     }
 
     public update_result(
       org.apache.accumulo.core.security.thrift.ThriftSecurityException sec,
       NotServingTabletException nste,
       ConstraintViolationException cve)
     {
       this();
       this.sec = sec;
       this.nste = nste;
       this.cve = cve;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public update_result(update_result other) {
       if (other.isSetSec()) {
         this.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException(other.sec);
       }
       if (other.isSetNste()) {
         this.nste = new NotServingTabletException(other.nste);
       }
       if (other.isSetCve()) {
         this.cve = new ConstraintViolationException(other.cve);
       }
     }
 
     public update_result deepCopy() {
       return new update_result(this);
     }
 
     @Override
     public void clear() {
       this.sec = null;
       this.nste = null;
       this.cve = null;
     }
 
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException getSec() {
       return this.sec;
     }
 
     public update_result setSec(org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
       this.sec = sec;
       return this;
     }
 
     public void unsetSec() {
       this.sec = null;
     }
 
     /** Returns true if field sec is set (has been assigned a value) and false otherwise */
     public boolean isSetSec() {
       return this.sec != null;
     }
 
     public void setSecIsSet(boolean value) {
       if (!value) {
         this.sec = null;
       }
     }
 
     public NotServingTabletException getNste() {
       return this.nste;
     }
 
     public update_result setNste(NotServingTabletException nste) {
       this.nste = nste;
       return this;
     }
 
     public void unsetNste() {
       this.nste = null;
     }
 
     /** Returns true if field nste is set (has been assigned a value) and false otherwise */
     public boolean isSetNste() {
       return this.nste != null;
     }
 
     public void setNsteIsSet(boolean value) {
       if (!value) {
         this.nste = null;
       }
     }
 
     public ConstraintViolationException getCve() {
       return this.cve;
     }
 
     public update_result setCve(ConstraintViolationException cve) {
       this.cve = cve;
       return this;
     }
 
     public void unsetCve() {
       this.cve = null;
     }
 
     /** Returns true if field cve is set (has been assigned a value) and false otherwise */
     public boolean isSetCve() {
       return this.cve != null;
     }
 
     public void setCveIsSet(boolean value) {
       if (!value) {
         this.cve = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SEC:
         if (value == null) {
           unsetSec();
         } else {
           setSec((org.apache.accumulo.core.security.thrift.ThriftSecurityException)value);
         }
         break;
 
       case NSTE:
         if (value == null) {
           unsetNste();
         } else {
           setNste((NotServingTabletException)value);
         }
         break;
 
       case CVE:
         if (value == null) {
           unsetCve();
         } else {
           setCve((ConstraintViolationException)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SEC:
         return getSec();
 
       case NSTE:
         return getNste();
 
       case CVE:
         return getCve();
 
       }
       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 SEC:
         return isSetSec();
       case NSTE:
         return isSetNste();
       case CVE:
         return isSetCve();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof update_result)
         return this.equals((update_result)that);
       return false;
     }
 
     public boolean equals(update_result that) {
       if (that == null)
         return false;
 
       boolean this_present_sec = true && this.isSetSec();
       boolean that_present_sec = true && that.isSetSec();
       if (this_present_sec || that_present_sec) {
         if (!(this_present_sec && that_present_sec))
           return false;
         if (!this.sec.equals(that.sec))
           return false;
       }
 
       boolean this_present_nste = true && this.isSetNste();
       boolean that_present_nste = true && that.isSetNste();
       if (this_present_nste || that_present_nste) {
         if (!(this_present_nste && that_present_nste))
           return false;
         if (!this.nste.equals(that.nste))
           return false;
       }
 
       boolean this_present_cve = true && this.isSetCve();
       boolean that_present_cve = true && that.isSetCve();
       if (this_present_cve || that_present_cve) {
         if (!(this_present_cve && that_present_cve))
           return false;
         if (!this.cve.equals(that.cve))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(update_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       update_result typedOther = (update_result)other;
 
       lastComparison = Boolean.valueOf(isSetSec()).compareTo(typedOther.isSetSec());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSec()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sec, typedOther.sec);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetNste()).compareTo(typedOther.isSetNste());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetNste()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nste, typedOther.nste);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCve()).compareTo(typedOther.isSetCve());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCve()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cve, typedOther.cve);
         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("update_result(");
       boolean first = true;
 
       sb.append("sec:");
       if (this.sec == null) {
         sb.append("null");
       } else {
         sb.append(this.sec);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("nste:");
       if (this.nste == null) {
         sb.append("null");
       } else {
         sb.append(this.nste);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("cve:");
       if (this.cve == null) {
         sb.append("null");
       } else {
         sb.append(this.cve);
       }
       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 {
         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 update_resultStandardSchemeFactory implements SchemeFactory {
       public update_resultStandardScheme getScheme() {
         return new update_resultStandardScheme();
       }
     }
 
     private static class update_resultStandardScheme extends StandardScheme<update_result> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, update_result 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: // SEC
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
                 struct.sec.read(iprot);
                 struct.setSecIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // NSTE
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.nste = new NotServingTabletException();
                 struct.nste.read(iprot);
                 struct.setNsteIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 3: // CVE
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.cve = new ConstraintViolationException();
                 struct.cve.read(iprot);
                 struct.setCveIsSet(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, update_result struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.sec != null) {
           oprot.writeFieldBegin(SEC_FIELD_DESC);
           struct.sec.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.nste != null) {
           oprot.writeFieldBegin(NSTE_FIELD_DESC);
           struct.nste.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.cve != null) {
           oprot.writeFieldBegin(CVE_FIELD_DESC);
           struct.cve.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class update_resultTupleSchemeFactory implements SchemeFactory {
       public update_resultTupleScheme getScheme() {
         return new update_resultTupleScheme();
       }
     }
 
     private static class update_resultTupleScheme extends TupleScheme<update_result> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, update_result struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetSec()) {
           optionals.set(0);
         }
         if (struct.isSetNste()) {
           optionals.set(1);
         }
         if (struct.isSetCve()) {
           optionals.set(2);
         }
         oprot.writeBitSet(optionals, 3);
         if (struct.isSetSec()) {
           struct.sec.write(oprot);
         }
         if (struct.isSetNste()) {
           struct.nste.write(oprot);
         }
         if (struct.isSetCve()) {
           struct.cve.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, update_result struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(3);
         if (incoming.get(0)) {
           struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
           struct.sec.read(iprot);
           struct.setSecIsSet(true);
         }
         if (incoming.get(1)) {
           struct.nste = new NotServingTabletException();
           struct.nste.read(iprot);
           struct.setNsteIsSet(true);
         }
         if (incoming.get(2)) {
           struct.cve = new ConstraintViolationException();
           struct.cve.read(iprot);
           struct.setCveIsSet(true);
         }
       }
     }
 
   }
 
   public static class bulkImport_args implements org.apache.thrift.TBase<bulkImport_args, bulkImport_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("bulkImport_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)3);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField TID_FIELD_DESC = new org.apache.thrift.protocol.TField("tid", org.apache.thrift.protocol.TType.I64, (short)4);
     private static final org.apache.thrift.protocol.TField FILES_FIELD_DESC = new org.apache.thrift.protocol.TField("files", org.apache.thrift.protocol.TType.MAP, (short)2);
     private static final org.apache.thrift.protocol.TField SET_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("setTime", org.apache.thrift.protocol.TType.BOOL, (short)5);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new bulkImport_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new bulkImport_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
     public long tid; // required
     public Map<org.apache.accumulo.core.data.thrift.TKeyExtent,Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo>> files; // required
     public boolean setTime; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)3, "tinfo"),
       CREDENTIAL((short)1, "credential"),
       TID((short)4, "tid"),
       FILES((short)2, "files"),
       SET_TIME((short)5, "setTime");
 
       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 3: // TINFO
             return TINFO;
           case 1: // CREDENTIAL
             return CREDENTIAL;
           case 4: // TID
             return TID;
           case 2: // FILES
             return FILES;
           case 5: // SET_TIME
             return SET_TIME;
           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 __TID_ISSET_ID = 0;
     private static final int __SETTIME_ISSET_ID = 1;
     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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       tmpMap.put(_Fields.TID, new org.apache.thrift.meta_data.FieldMetaData("tid", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
       tmpMap.put(_Fields.FILES, new org.apache.thrift.meta_data.FieldMetaData("files", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.MAP          , "TabletFiles")));
       tmpMap.put(_Fields.SET_TIME, new org.apache.thrift.meta_data.FieldMetaData("setTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(bulkImport_args.class, metaDataMap);
     }
 
     public bulkImport_args() {
     }
 
     public bulkImport_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential,
       long tid,
       Map<org.apache.accumulo.core.data.thrift.TKeyExtent,Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo>> files,
       boolean setTime)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
       this.tid = tid;
       setTidIsSet(true);
       this.files = files;
       this.setTime = setTime;
       setSetTimeIsSet(true);
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public bulkImport_args(bulkImport_args other) {
       __isset_bitfield = other.__isset_bitfield;
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
       this.tid = other.tid;
       if (other.isSetFiles()) {
         this.files = other.files;
       }
       this.setTime = other.setTime;
     }
 
     public bulkImport_args deepCopy() {
       return new bulkImport_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
       setTidIsSet(false);
       this.tid = 0;
       this.files = null;
       setSetTimeIsSet(false);
       this.setTime = false;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public bulkImport_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public bulkImport_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public long getTid() {
       return this.tid;
     }
 
     public bulkImport_args setTid(long tid) {
       this.tid = tid;
       setTidIsSet(true);
       return this;
     }
 
     public void unsetTid() {
       __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __TID_ISSET_ID);
     }
 
     /** Returns true if field tid is set (has been assigned a value) and false otherwise */
     public boolean isSetTid() {
       return EncodingUtils.testBit(__isset_bitfield, __TID_ISSET_ID);
     }
 
     public void setTidIsSet(boolean value) {
       __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TID_ISSET_ID, value);
     }
 
     public int getFilesSize() {
       return (this.files == null) ? 0 : this.files.size();
     }
 
     public void putToFiles(org.apache.accumulo.core.data.thrift.TKeyExtent key, Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo> val) {
       if (this.files == null) {
         this.files = new HashMap<org.apache.accumulo.core.data.thrift.TKeyExtent,Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo>>();
       }
       this.files.put(key, val);
     }
 
     public Map<org.apache.accumulo.core.data.thrift.TKeyExtent,Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo>> getFiles() {
       return this.files;
     }
 
     public bulkImport_args setFiles(Map<org.apache.accumulo.core.data.thrift.TKeyExtent,Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo>> files) {
       this.files = files;
       return this;
     }
 
     public void unsetFiles() {
       this.files = null;
     }
 
     /** Returns true if field files is set (has been assigned a value) and false otherwise */
     public boolean isSetFiles() {
       return this.files != null;
     }
 
     public void setFilesIsSet(boolean value) {
       if (!value) {
         this.files = null;
       }
     }
 
     public boolean isSetTime() {
       return this.setTime;
     }
 
     public bulkImport_args setSetTime(boolean setTime) {
       this.setTime = setTime;
       setSetTimeIsSet(true);
       return this;
     }
 
     public void unsetSetTime() {
       __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SETTIME_ISSET_ID);
     }
 
     /** Returns true if field setTime is set (has been assigned a value) and false otherwise */
     public boolean isSetSetTime() {
       return EncodingUtils.testBit(__isset_bitfield, __SETTIME_ISSET_ID);
     }
 
     public void setSetTimeIsSet(boolean value) {
       __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SETTIME_ISSET_ID, value);
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       case TID:
         if (value == null) {
           unsetTid();
         } else {
           setTid((Long)value);
         }
         break;
 
       case FILES:
         if (value == null) {
           unsetFiles();
         } else {
           setFiles((Map<org.apache.accumulo.core.data.thrift.TKeyExtent,Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo>>)value);
         }
         break;
 
       case SET_TIME:
         if (value == null) {
           unsetSetTime();
         } else {
           setSetTime((Boolean)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       case TID:
         return Long.valueOf(getTid());
 
       case FILES:
         return getFiles();
 
       case SET_TIME:
         return Boolean.valueOf(isSetTime());
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       case TID:
         return isSetTid();
       case FILES:
         return isSetFiles();
       case SET_TIME:
         return isSetSetTime();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof bulkImport_args)
         return this.equals((bulkImport_args)that);
       return false;
     }
 
     public boolean equals(bulkImport_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       boolean this_present_tid = true;
       boolean that_present_tid = true;
       if (this_present_tid || that_present_tid) {
         if (!(this_present_tid && that_present_tid))
           return false;
         if (this.tid != that.tid)
           return false;
       }
 
       boolean this_present_files = true && this.isSetFiles();
       boolean that_present_files = true && that.isSetFiles();
       if (this_present_files || that_present_files) {
         if (!(this_present_files && that_present_files))
           return false;
         if (!this.files.equals(that.files))
           return false;
       }
 
       boolean this_present_setTime = true;
       boolean that_present_setTime = true;
       if (this_present_setTime || that_present_setTime) {
         if (!(this_present_setTime && that_present_setTime))
           return false;
         if (this.setTime != that.setTime)
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(bulkImport_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       bulkImport_args typedOther = (bulkImport_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetTid()).compareTo(typedOther.isSetTid());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTid()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tid, typedOther.tid);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetFiles()).compareTo(typedOther.isSetFiles());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetFiles()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.files, typedOther.files);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetSetTime()).compareTo(typedOther.isSetSetTime());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSetTime()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.setTime, typedOther.setTime);
         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("bulkImport_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("tid:");
       sb.append(this.tid);
       first = false;
       if (!first) sb.append(", ");
       sb.append("files:");
       if (this.files == null) {
         sb.append("null");
       } else {
         sb.append(this.files);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("setTime:");
       sb.append(this.setTime);
       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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.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, 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 bulkImport_argsStandardSchemeFactory implements SchemeFactory {
       public bulkImport_argsStandardScheme getScheme() {
         return new bulkImport_argsStandardScheme();
       }
     }
 
     private static class bulkImport_argsStandardScheme extends StandardScheme<bulkImport_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, bulkImport_args 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 3: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 4: // TID
               if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
                 struct.tid = iprot.readI64();
                 struct.setTidIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // FILES
               if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
                 {
                   org.apache.thrift.protocol.TMap _map220 = iprot.readMapBegin();
                   struct.files = new HashMap<org.apache.accumulo.core.data.thrift.TKeyExtent,Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo>>(2*_map220.size);
                   for (int _i221 = 0; _i221 < _map220.size; ++_i221)
                   {
                     org.apache.accumulo.core.data.thrift.TKeyExtent _key222; // required
                     Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo> _val223; // required
                     _key222 = new org.apache.accumulo.core.data.thrift.TKeyExtent();
                     _key222.read(iprot);
                     {
                       org.apache.thrift.protocol.TMap _map224 = iprot.readMapBegin();
                       _val223 = new HashMap<String,org.apache.accumulo.core.data.thrift.MapFileInfo>(2*_map224.size);
                       for (int _i225 = 0; _i225 < _map224.size; ++_i225)
                       {
                         String _key226; // required
                         org.apache.accumulo.core.data.thrift.MapFileInfo _val227; // required
                         _key226 = iprot.readString();
                         _val227 = new org.apache.accumulo.core.data.thrift.MapFileInfo();
                         _val227.read(iprot);
                         _val223.put(_key226, _val227);
                       }
                       iprot.readMapEnd();
                     }
                     struct.files.put(_key222, _val223);
                   }
                   iprot.readMapEnd();
                 }
                 struct.setFilesIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 5: // SET_TIME
               if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
                 struct.setTime = iprot.readBool();
                 struct.setSetTimeIsSet(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, bulkImport_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.files != null) {
           oprot.writeFieldBegin(FILES_FIELD_DESC);
           {
             oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRUCT, org.apache.thrift.protocol.TType.MAP, struct.files.size()));
             for (Map.Entry<org.apache.accumulo.core.data.thrift.TKeyExtent, Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo>> _iter228 : struct.files.entrySet())
             {
               _iter228.getKey().write(oprot);
               {
                 oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, _iter228.getValue().size()));
                 for (Map.Entry<String, org.apache.accumulo.core.data.thrift.MapFileInfo> _iter229 : _iter228.getValue().entrySet())
                 {
                   oprot.writeString(_iter229.getKey());
                   _iter229.getValue().write(oprot);
                 }
                 oprot.writeMapEnd();
               }
             }
             oprot.writeMapEnd();
           }
           oprot.writeFieldEnd();
         }
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldBegin(TID_FIELD_DESC);
         oprot.writeI64(struct.tid);
         oprot.writeFieldEnd();
         oprot.writeFieldBegin(SET_TIME_FIELD_DESC);
         oprot.writeBool(struct.setTime);
         oprot.writeFieldEnd();
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class bulkImport_argsTupleSchemeFactory implements SchemeFactory {
       public bulkImport_argsTupleScheme getScheme() {
         return new bulkImport_argsTupleScheme();
       }
     }
 
     private static class bulkImport_argsTupleScheme extends TupleScheme<bulkImport_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, bulkImport_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         if (struct.isSetTid()) {
           optionals.set(2);
         }
         if (struct.isSetFiles()) {
           optionals.set(3);
         }
         if (struct.isSetSetTime()) {
           optionals.set(4);
         }
         oprot.writeBitSet(optionals, 5);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
         if (struct.isSetTid()) {
           oprot.writeI64(struct.tid);
         }
         if (struct.isSetFiles()) {
           {
             oprot.writeI32(struct.files.size());
             for (Map.Entry<org.apache.accumulo.core.data.thrift.TKeyExtent, Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo>> _iter230 : struct.files.entrySet())
             {
               _iter230.getKey().write(oprot);
               {
                 oprot.writeI32(_iter230.getValue().size());
                 for (Map.Entry<String, org.apache.accumulo.core.data.thrift.MapFileInfo> _iter231 : _iter230.getValue().entrySet())
                 {
                   oprot.writeString(_iter231.getKey());
                   _iter231.getValue().write(oprot);
                 }
               }
             }
           }
         }
         if (struct.isSetSetTime()) {
           oprot.writeBool(struct.setTime);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, bulkImport_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(5);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
         if (incoming.get(2)) {
           struct.tid = iprot.readI64();
           struct.setTidIsSet(true);
         }
         if (incoming.get(3)) {
           {
             org.apache.thrift.protocol.TMap _map232 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRUCT, org.apache.thrift.protocol.TType.MAP, iprot.readI32());
             struct.files = new HashMap<org.apache.accumulo.core.data.thrift.TKeyExtent,Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo>>(2*_map232.size);
             for (int _i233 = 0; _i233 < _map232.size; ++_i233)
             {
               org.apache.accumulo.core.data.thrift.TKeyExtent _key234; // required
               Map<String,org.apache.accumulo.core.data.thrift.MapFileInfo> _val235; // required
               _key234 = new org.apache.accumulo.core.data.thrift.TKeyExtent();
               _key234.read(iprot);
               {
                 org.apache.thrift.protocol.TMap _map236 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
                 _val235 = new HashMap<String,org.apache.accumulo.core.data.thrift.MapFileInfo>(2*_map236.size);
                 for (int _i237 = 0; _i237 < _map236.size; ++_i237)
                 {
                   String _key238; // required
                   org.apache.accumulo.core.data.thrift.MapFileInfo _val239; // required
                   _key238 = iprot.readString();
                   _val239 = new org.apache.accumulo.core.data.thrift.MapFileInfo();
                   _val239.read(iprot);
                   _val235.put(_key238, _val239);
                 }
               }
               struct.files.put(_key234, _val235);
             }
           }
           struct.setFilesIsSet(true);
         }
         if (incoming.get(4)) {
           struct.setTime = iprot.readBool();
           struct.setSetTimeIsSet(true);
         }
       }
     }
 
   }
 
   public static class bulkImport_result implements org.apache.thrift.TBase<bulkImport_result, bulkImport_result._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("bulkImport_result");
 
     private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
     private static final org.apache.thrift.protocol.TField SEC_FIELD_DESC = new org.apache.thrift.protocol.TField("sec", org.apache.thrift.protocol.TType.STRUCT, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new bulkImport_resultStandardSchemeFactory());
       schemes.put(TupleScheme.class, new bulkImport_resultTupleSchemeFactory());
     }
 
     public List<org.apache.accumulo.core.data.thrift.TKeyExtent> success; // required
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException sec; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       SUCCESS((short)0, "success"),
       SEC((short)1, "sec");
 
       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 0: // SUCCESS
             return SUCCESS;
           case 1: // SEC
             return SEC;
           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
     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.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           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, org.apache.accumulo.core.data.thrift.TKeyExtent.class))));
       tmpMap.put(_Fields.SEC, new org.apache.thrift.meta_data.FieldMetaData("sec", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(bulkImport_result.class, metaDataMap);
     }
 
     public bulkImport_result() {
     }
 
     public bulkImport_result(
       List<org.apache.accumulo.core.data.thrift.TKeyExtent> success,
       org.apache.accumulo.core.security.thrift.ThriftSecurityException sec)
     {
       this();
       this.success = success;
       this.sec = sec;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public bulkImport_result(bulkImport_result other) {
       if (other.isSetSuccess()) {
         List<org.apache.accumulo.core.data.thrift.TKeyExtent> __this__success = new ArrayList<org.apache.accumulo.core.data.thrift.TKeyExtent>();
         for (org.apache.accumulo.core.data.thrift.TKeyExtent other_element : other.success) {
           __this__success.add(new org.apache.accumulo.core.data.thrift.TKeyExtent(other_element));
         }
         this.success = __this__success;
       }
       if (other.isSetSec()) {
         this.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException(other.sec);
       }
     }
 
     public bulkImport_result deepCopy() {
       return new bulkImport_result(this);
     }
 
     @Override
     public void clear() {
       this.success = null;
       this.sec = null;
     }
 
     public int getSuccessSize() {
       return (this.success == null) ? 0 : this.success.size();
     }
 
     public java.util.Iterator<org.apache.accumulo.core.data.thrift.TKeyExtent> getSuccessIterator() {
       return (this.success == null) ? null : this.success.iterator();
     }
 
     public void addToSuccess(org.apache.accumulo.core.data.thrift.TKeyExtent elem) {
       if (this.success == null) {
         this.success = new ArrayList<org.apache.accumulo.core.data.thrift.TKeyExtent>();
       }
       this.success.add(elem);
     }
 
     public List<org.apache.accumulo.core.data.thrift.TKeyExtent> getSuccess() {
       return this.success;
     }
 
     public bulkImport_result setSuccess(List<org.apache.accumulo.core.data.thrift.TKeyExtent> success) {
       this.success = success;
       return this;
     }
 
     public void unsetSuccess() {
       this.success = null;
     }
 
     /** Returns true if field success is set (has been assigned a value) and false otherwise */
     public boolean isSetSuccess() {
       return this.success != null;
     }
 
     public void setSuccessIsSet(boolean value) {
       if (!value) {
         this.success = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException getSec() {
       return this.sec;
     }
 
     public bulkImport_result setSec(org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
       this.sec = sec;
       return this;
     }
 
     public void unsetSec() {
       this.sec = null;
     }
 
     /** Returns true if field sec is set (has been assigned a value) and false otherwise */
     public boolean isSetSec() {
       return this.sec != null;
     }
 
     public void setSecIsSet(boolean value) {
       if (!value) {
         this.sec = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
           setSuccess((List<org.apache.accumulo.core.data.thrift.TKeyExtent>)value);
         }
         break;
 
       case SEC:
         if (value == null) {
           unsetSec();
         } else {
           setSec((org.apache.accumulo.core.security.thrift.ThriftSecurityException)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
         return getSuccess();
 
       case SEC:
         return getSec();
 
       }
       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 SUCCESS:
         return isSetSuccess();
       case SEC:
         return isSetSec();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof bulkImport_result)
         return this.equals((bulkImport_result)that);
       return false;
     }
 
     public boolean equals(bulkImport_result that) {
       if (that == null)
         return false;
 
       boolean this_present_success = true && this.isSetSuccess();
       boolean that_present_success = true && that.isSetSuccess();
       if (this_present_success || that_present_success) {
         if (!(this_present_success && that_present_success))
           return false;
         if (!this.success.equals(that.success))
           return false;
       }
 
       boolean this_present_sec = true && this.isSetSec();
       boolean that_present_sec = true && that.isSetSec();
       if (this_present_sec || that_present_sec) {
         if (!(this_present_sec && that_present_sec))
           return false;
         if (!this.sec.equals(that.sec))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(bulkImport_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       bulkImport_result typedOther = (bulkImport_result)other;
 
       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSuccess()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetSec()).compareTo(typedOther.isSetSec());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSec()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sec, typedOther.sec);
         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("bulkImport_result(");
       boolean first = true;
 
       sb.append("success:");
       if (this.success == null) {
         sb.append("null");
       } else {
         sb.append(this.success);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("sec:");
       if (this.sec == null) {
         sb.append("null");
       } else {
         sb.append(this.sec);
       }
       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 {
         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 bulkImport_resultStandardSchemeFactory implements SchemeFactory {
       public bulkImport_resultStandardScheme getScheme() {
         return new bulkImport_resultStandardScheme();
       }
     }
 
     private static class bulkImport_resultStandardScheme extends StandardScheme<bulkImport_result> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, bulkImport_result 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 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                 {
                   org.apache.thrift.protocol.TList _list240 = iprot.readListBegin();
                   struct.success = new ArrayList<org.apache.accumulo.core.data.thrift.TKeyExtent>(_list240.size);
                   for (int _i241 = 0; _i241 < _list240.size; ++_i241)
                   {
                     org.apache.accumulo.core.data.thrift.TKeyExtent _elem242; // required
                     _elem242 = new org.apache.accumulo.core.data.thrift.TKeyExtent();
                     _elem242.read(iprot);
                     struct.success.add(_elem242);
                   }
                   iprot.readListEnd();
                 }
                 struct.setSuccessIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // SEC
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
                 struct.sec.read(iprot);
                 struct.setSecIsSet(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, bulkImport_result struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.success != null) {
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
             for (org.apache.accumulo.core.data.thrift.TKeyExtent _iter243 : struct.success)
             {
               _iter243.write(oprot);
             }
             oprot.writeListEnd();
           }
           oprot.writeFieldEnd();
         }
         if (struct.sec != null) {
           oprot.writeFieldBegin(SEC_FIELD_DESC);
           struct.sec.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class bulkImport_resultTupleSchemeFactory implements SchemeFactory {
       public bulkImport_resultTupleScheme getScheme() {
         return new bulkImport_resultTupleScheme();
       }
     }
 
     private static class bulkImport_resultTupleScheme extends TupleScheme<bulkImport_result> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, bulkImport_result struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetSuccess()) {
           optionals.set(0);
         }
         if (struct.isSetSec()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetSuccess()) {
           {
             oprot.writeI32(struct.success.size());
             for (org.apache.accumulo.core.data.thrift.TKeyExtent _iter244 : struct.success)
             {
               _iter244.write(oprot);
             }
           }
         }
         if (struct.isSetSec()) {
           struct.sec.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, bulkImport_result struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           {
             org.apache.thrift.protocol.TList _list245 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
             struct.success = new ArrayList<org.apache.accumulo.core.data.thrift.TKeyExtent>(_list245.size);
             for (int _i246 = 0; _i246 < _list245.size; ++_i246)
             {
               org.apache.accumulo.core.data.thrift.TKeyExtent _elem247; // required
               _elem247 = new org.apache.accumulo.core.data.thrift.TKeyExtent();
               _elem247.read(iprot);
               struct.success.add(_elem247);
             }
           }
           struct.setSuccessIsSet(true);
         }
         if (incoming.get(1)) {
           struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
           struct.sec.read(iprot);
           struct.setSecIsSet(true);
         }
       }
     }
 
   }
 
   public static class splitTablet_args implements org.apache.thrift.TBase<splitTablet_args, splitTablet_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("splitTablet_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)4);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField EXTENT_FIELD_DESC = new org.apache.thrift.protocol.TField("extent", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField SPLIT_POINT_FIELD_DESC = new org.apache.thrift.protocol.TField("splitPoint", org.apache.thrift.protocol.TType.STRING, (short)3);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new splitTablet_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new splitTablet_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
     public org.apache.accumulo.core.data.thrift.TKeyExtent extent; // required
     public ByteBuffer splitPoint; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)4, "tinfo"),
       CREDENTIAL((short)1, "credential"),
       EXTENT((short)2, "extent"),
       SPLIT_POINT((short)3, "splitPoint");
 
       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 4: // TINFO
             return TINFO;
           case 1: // CREDENTIAL
             return CREDENTIAL;
           case 2: // EXTENT
             return EXTENT;
           case 3: // SPLIT_POINT
             return SPLIT_POINT;
           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
     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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       tmpMap.put(_Fields.EXTENT, new org.apache.thrift.meta_data.FieldMetaData("extent", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.data.thrift.TKeyExtent.class)));
       tmpMap.put(_Fields.SPLIT_POINT, new org.apache.thrift.meta_data.FieldMetaData("splitPoint", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(splitTablet_args.class, metaDataMap);
     }
 
     public splitTablet_args() {
     }
 
     public splitTablet_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential,
       org.apache.accumulo.core.data.thrift.TKeyExtent extent,
       ByteBuffer splitPoint)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
       this.extent = extent;
       this.splitPoint = splitPoint;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public splitTablet_args(splitTablet_args other) {
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
       if (other.isSetExtent()) {
         this.extent = new org.apache.accumulo.core.data.thrift.TKeyExtent(other.extent);
       }
       if (other.isSetSplitPoint()) {
         this.splitPoint = org.apache.thrift.TBaseHelper.copyBinary(other.splitPoint);
 ;
       }
     }
 
     public splitTablet_args deepCopy() {
       return new splitTablet_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
       this.extent = null;
       this.splitPoint = null;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public splitTablet_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public splitTablet_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public org.apache.accumulo.core.data.thrift.TKeyExtent getExtent() {
       return this.extent;
     }
 
     public splitTablet_args setExtent(org.apache.accumulo.core.data.thrift.TKeyExtent extent) {
       this.extent = extent;
       return this;
     }
 
     public void unsetExtent() {
       this.extent = null;
     }
 
     /** Returns true if field extent is set (has been assigned a value) and false otherwise */
     public boolean isSetExtent() {
       return this.extent != null;
     }
 
     public void setExtentIsSet(boolean value) {
       if (!value) {
         this.extent = null;
       }
     }
 
     public byte[] getSplitPoint() {
       setSplitPoint(org.apache.thrift.TBaseHelper.rightSize(splitPoint));
       return splitPoint == null ? null : splitPoint.array();
     }
 
     public ByteBuffer bufferForSplitPoint() {
       return splitPoint;
     }
 
     public splitTablet_args setSplitPoint(byte[] splitPoint) {
       setSplitPoint(splitPoint == null ? (ByteBuffer)null : ByteBuffer.wrap(splitPoint));
       return this;
     }
 
     public splitTablet_args setSplitPoint(ByteBuffer splitPoint) {
       this.splitPoint = splitPoint;
       return this;
     }
 
     public void unsetSplitPoint() {
       this.splitPoint = null;
     }
 
     /** Returns true if field splitPoint is set (has been assigned a value) and false otherwise */
     public boolean isSetSplitPoint() {
       return this.splitPoint != null;
     }
 
     public void setSplitPointIsSet(boolean value) {
       if (!value) {
         this.splitPoint = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       case EXTENT:
         if (value == null) {
           unsetExtent();
         } else {
           setExtent((org.apache.accumulo.core.data.thrift.TKeyExtent)value);
         }
         break;
 
       case SPLIT_POINT:
         if (value == null) {
           unsetSplitPoint();
         } else {
           setSplitPoint((ByteBuffer)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       case EXTENT:
         return getExtent();
 
       case SPLIT_POINT:
         return getSplitPoint();
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       case EXTENT:
         return isSetExtent();
       case SPLIT_POINT:
         return isSetSplitPoint();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof splitTablet_args)
         return this.equals((splitTablet_args)that);
       return false;
     }
 
     public boolean equals(splitTablet_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       boolean this_present_extent = true && this.isSetExtent();
       boolean that_present_extent = true && that.isSetExtent();
       if (this_present_extent || that_present_extent) {
         if (!(this_present_extent && that_present_extent))
           return false;
         if (!this.extent.equals(that.extent))
           return false;
       }
 
       boolean this_present_splitPoint = true && this.isSetSplitPoint();
       boolean that_present_splitPoint = true && that.isSetSplitPoint();
       if (this_present_splitPoint || that_present_splitPoint) {
         if (!(this_present_splitPoint && that_present_splitPoint))
           return false;
         if (!this.splitPoint.equals(that.splitPoint))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(splitTablet_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       splitTablet_args typedOther = (splitTablet_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetExtent()).compareTo(typedOther.isSetExtent());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetExtent()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extent, typedOther.extent);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetSplitPoint()).compareTo(typedOther.isSetSplitPoint());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSplitPoint()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.splitPoint, typedOther.splitPoint);
         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("splitTablet_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("extent:");
       if (this.extent == null) {
         sb.append("null");
       } else {
         sb.append(this.extent);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("splitPoint:");
       if (this.splitPoint == null) {
         sb.append("null");
       } else {
         org.apache.thrift.TBaseHelper.toString(this.splitPoint, 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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.validate();
       }
       if (extent != null) {
         extent.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, ClassNotFoundException {
       try {
         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 splitTablet_argsStandardSchemeFactory implements SchemeFactory {
       public splitTablet_argsStandardScheme getScheme() {
         return new splitTablet_argsStandardScheme();
       }
     }
 
     private static class splitTablet_argsStandardScheme extends StandardScheme<splitTablet_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, splitTablet_args 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 4: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // EXTENT
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.extent = new org.apache.accumulo.core.data.thrift.TKeyExtent();
                 struct.extent.read(iprot);
                 struct.setExtentIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 3: // SPLIT_POINT
               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                 struct.splitPoint = iprot.readBinary();
                 struct.setSplitPointIsSet(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, splitTablet_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.extent != null) {
           oprot.writeFieldBegin(EXTENT_FIELD_DESC);
           struct.extent.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.splitPoint != null) {
           oprot.writeFieldBegin(SPLIT_POINT_FIELD_DESC);
           oprot.writeBinary(struct.splitPoint);
           oprot.writeFieldEnd();
         }
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class splitTablet_argsTupleSchemeFactory implements SchemeFactory {
       public splitTablet_argsTupleScheme getScheme() {
         return new splitTablet_argsTupleScheme();
       }
     }
 
     private static class splitTablet_argsTupleScheme extends TupleScheme<splitTablet_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, splitTablet_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         if (struct.isSetExtent()) {
           optionals.set(2);
         }
         if (struct.isSetSplitPoint()) {
           optionals.set(3);
         }
         oprot.writeBitSet(optionals, 4);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
         if (struct.isSetExtent()) {
           struct.extent.write(oprot);
         }
         if (struct.isSetSplitPoint()) {
           oprot.writeBinary(struct.splitPoint);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, splitTablet_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(4);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
         if (incoming.get(2)) {
           struct.extent = new org.apache.accumulo.core.data.thrift.TKeyExtent();
           struct.extent.read(iprot);
           struct.setExtentIsSet(true);
         }
         if (incoming.get(3)) {
           struct.splitPoint = iprot.readBinary();
           struct.setSplitPointIsSet(true);
         }
       }
     }
 
   }
 
   public static class splitTablet_result implements org.apache.thrift.TBase<splitTablet_result, splitTablet_result._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("splitTablet_result");
 
     private static final org.apache.thrift.protocol.TField SEC_FIELD_DESC = new org.apache.thrift.protocol.TField("sec", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField NSTE_FIELD_DESC = new org.apache.thrift.protocol.TField("nste", org.apache.thrift.protocol.TType.STRUCT, (short)2);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new splitTablet_resultStandardSchemeFactory());
       schemes.put(TupleScheme.class, new splitTablet_resultTupleSchemeFactory());
     }
 
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException sec; // required
     public NotServingTabletException nste; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       SEC((short)1, "sec"),
       NSTE((short)2, "nste");
 
       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: // SEC
             return SEC;
           case 2: // NSTE
             return NSTE;
           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
     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.SEC, new org.apache.thrift.meta_data.FieldMetaData("sec", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       tmpMap.put(_Fields.NSTE, new org.apache.thrift.meta_data.FieldMetaData("nste", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(splitTablet_result.class, metaDataMap);
     }
 
     public splitTablet_result() {
     }
 
     public splitTablet_result(
       org.apache.accumulo.core.security.thrift.ThriftSecurityException sec,
       NotServingTabletException nste)
     {
       this();
       this.sec = sec;
       this.nste = nste;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public splitTablet_result(splitTablet_result other) {
       if (other.isSetSec()) {
         this.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException(other.sec);
       }
       if (other.isSetNste()) {
         this.nste = new NotServingTabletException(other.nste);
       }
     }
 
     public splitTablet_result deepCopy() {
       return new splitTablet_result(this);
     }
 
     @Override
     public void clear() {
       this.sec = null;
       this.nste = null;
     }
 
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException getSec() {
       return this.sec;
     }
 
     public splitTablet_result setSec(org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
       this.sec = sec;
       return this;
     }
 
     public void unsetSec() {
       this.sec = null;
     }
 
     /** Returns true if field sec is set (has been assigned a value) and false otherwise */
     public boolean isSetSec() {
       return this.sec != null;
     }
 
     public void setSecIsSet(boolean value) {
       if (!value) {
         this.sec = null;
       }
     }
 
     public NotServingTabletException getNste() {
       return this.nste;
     }
 
     public splitTablet_result setNste(NotServingTabletException nste) {
       this.nste = nste;
       return this;
     }
 
     public void unsetNste() {
       this.nste = null;
     }
 
     /** Returns true if field nste is set (has been assigned a value) and false otherwise */
     public boolean isSetNste() {
       return this.nste != null;
     }
 
     public void setNsteIsSet(boolean value) {
       if (!value) {
         this.nste = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SEC:
         if (value == null) {
           unsetSec();
         } else {
           setSec((org.apache.accumulo.core.security.thrift.ThriftSecurityException)value);
         }
         break;
 
       case NSTE:
         if (value == null) {
           unsetNste();
         } else {
           setNste((NotServingTabletException)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SEC:
         return getSec();
 
       case NSTE:
         return getNste();
 
       }
       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 SEC:
         return isSetSec();
       case NSTE:
         return isSetNste();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof splitTablet_result)
         return this.equals((splitTablet_result)that);
       return false;
     }
 
     public boolean equals(splitTablet_result that) {
       if (that == null)
         return false;
 
       boolean this_present_sec = true && this.isSetSec();
       boolean that_present_sec = true && that.isSetSec();
       if (this_present_sec || that_present_sec) {
         if (!(this_present_sec && that_present_sec))
           return false;
         if (!this.sec.equals(that.sec))
           return false;
       }
 
       boolean this_present_nste = true && this.isSetNste();
       boolean that_present_nste = true && that.isSetNste();
       if (this_present_nste || that_present_nste) {
         if (!(this_present_nste && that_present_nste))
           return false;
         if (!this.nste.equals(that.nste))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(splitTablet_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       splitTablet_result typedOther = (splitTablet_result)other;
 
       lastComparison = Boolean.valueOf(isSetSec()).compareTo(typedOther.isSetSec());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSec()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sec, typedOther.sec);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetNste()).compareTo(typedOther.isSetNste());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetNste()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nste, typedOther.nste);
         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("splitTablet_result(");
       boolean first = true;
 
       sb.append("sec:");
       if (this.sec == null) {
         sb.append("null");
       } else {
         sb.append(this.sec);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("nste:");
       if (this.nste == null) {
         sb.append("null");
       } else {
         sb.append(this.nste);
       }
       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 {
         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 splitTablet_resultStandardSchemeFactory implements SchemeFactory {
       public splitTablet_resultStandardScheme getScheme() {
         return new splitTablet_resultStandardScheme();
       }
     }
 
     private static class splitTablet_resultStandardScheme extends StandardScheme<splitTablet_result> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, splitTablet_result 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: // SEC
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
                 struct.sec.read(iprot);
                 struct.setSecIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // NSTE
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.nste = new NotServingTabletException();
                 struct.nste.read(iprot);
                 struct.setNsteIsSet(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, splitTablet_result struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.sec != null) {
           oprot.writeFieldBegin(SEC_FIELD_DESC);
           struct.sec.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.nste != null) {
           oprot.writeFieldBegin(NSTE_FIELD_DESC);
           struct.nste.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class splitTablet_resultTupleSchemeFactory implements SchemeFactory {
       public splitTablet_resultTupleScheme getScheme() {
         return new splitTablet_resultTupleScheme();
       }
     }
 
     private static class splitTablet_resultTupleScheme extends TupleScheme<splitTablet_result> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, splitTablet_result struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetSec()) {
           optionals.set(0);
         }
         if (struct.isSetNste()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetSec()) {
           struct.sec.write(oprot);
         }
         if (struct.isSetNste()) {
           struct.nste.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, splitTablet_result struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
           struct.sec.read(iprot);
           struct.setSecIsSet(true);
         }
         if (incoming.get(1)) {
           struct.nste = new NotServingTabletException();
           struct.nste.read(iprot);
           struct.setNsteIsSet(true);
         }
       }
     }
 
   }
 
   public static class loadTablet_args implements org.apache.thrift.TBase<loadTablet_args, loadTablet_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("loadTablet_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)5);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField LOCK_FIELD_DESC = new org.apache.thrift.protocol.TField("lock", org.apache.thrift.protocol.TType.STRING, (short)4);
     private static final org.apache.thrift.protocol.TField EXTENT_FIELD_DESC = new org.apache.thrift.protocol.TField("extent", org.apache.thrift.protocol.TType.STRUCT, (short)2);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new loadTablet_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new loadTablet_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
     public String lock; // required
     public org.apache.accumulo.core.data.thrift.TKeyExtent extent; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)5, "tinfo"),
       CREDENTIAL((short)1, "credential"),
       LOCK((short)4, "lock"),
       EXTENT((short)2, "extent");
 
       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 5: // TINFO
             return TINFO;
           case 1: // CREDENTIAL
             return CREDENTIAL;
           case 4: // LOCK
             return LOCK;
           case 2: // EXTENT
             return EXTENT;
           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
     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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       tmpMap.put(_Fields.LOCK, new org.apache.thrift.meta_data.FieldMetaData("lock", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
       tmpMap.put(_Fields.EXTENT, new org.apache.thrift.meta_data.FieldMetaData("extent", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.data.thrift.TKeyExtent.class)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(loadTablet_args.class, metaDataMap);
     }
 
     public loadTablet_args() {
     }
 
     public loadTablet_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential,
       String lock,
       org.apache.accumulo.core.data.thrift.TKeyExtent extent)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
       this.lock = lock;
       this.extent = extent;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public loadTablet_args(loadTablet_args other) {
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
       if (other.isSetLock()) {
         this.lock = other.lock;
       }
       if (other.isSetExtent()) {
         this.extent = new org.apache.accumulo.core.data.thrift.TKeyExtent(other.extent);
       }
     }
 
     public loadTablet_args deepCopy() {
       return new loadTablet_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
       this.lock = null;
       this.extent = null;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public loadTablet_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public loadTablet_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public String getLock() {
       return this.lock;
     }
 
     public loadTablet_args setLock(String lock) {
       this.lock = lock;
       return this;
     }
 
     public void unsetLock() {
       this.lock = null;
     }
 
     /** Returns true if field lock is set (has been assigned a value) and false otherwise */
     public boolean isSetLock() {
       return this.lock != null;
     }
 
     public void setLockIsSet(boolean value) {
       if (!value) {
         this.lock = null;
       }
     }
 
     public org.apache.accumulo.core.data.thrift.TKeyExtent getExtent() {
       return this.extent;
     }
 
     public loadTablet_args setExtent(org.apache.accumulo.core.data.thrift.TKeyExtent extent) {
       this.extent = extent;
       return this;
     }
 
     public void unsetExtent() {
       this.extent = null;
     }
 
     /** Returns true if field extent is set (has been assigned a value) and false otherwise */
     public boolean isSetExtent() {
       return this.extent != null;
     }
 
     public void setExtentIsSet(boolean value) {
       if (!value) {
         this.extent = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       case LOCK:
         if (value == null) {
           unsetLock();
         } else {
           setLock((String)value);
         }
         break;
 
       case EXTENT:
         if (value == null) {
           unsetExtent();
         } else {
           setExtent((org.apache.accumulo.core.data.thrift.TKeyExtent)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       case LOCK:
         return getLock();
 
       case EXTENT:
         return getExtent();
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       case LOCK:
         return isSetLock();
       case EXTENT:
         return isSetExtent();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof loadTablet_args)
         return this.equals((loadTablet_args)that);
       return false;
     }
 
     public boolean equals(loadTablet_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       boolean this_present_lock = true && this.isSetLock();
       boolean that_present_lock = true && that.isSetLock();
       if (this_present_lock || that_present_lock) {
         if (!(this_present_lock && that_present_lock))
           return false;
         if (!this.lock.equals(that.lock))
           return false;
       }
 
       boolean this_present_extent = true && this.isSetExtent();
       boolean that_present_extent = true && that.isSetExtent();
       if (this_present_extent || that_present_extent) {
         if (!(this_present_extent && that_present_extent))
           return false;
         if (!this.extent.equals(that.extent))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(loadTablet_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       loadTablet_args typedOther = (loadTablet_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetLock()).compareTo(typedOther.isSetLock());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetLock()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lock, typedOther.lock);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetExtent()).compareTo(typedOther.isSetExtent());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetExtent()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extent, typedOther.extent);
         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("loadTablet_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("lock:");
       if (this.lock == null) {
         sb.append("null");
       } else {
         sb.append(this.lock);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("extent:");
       if (this.extent == null) {
         sb.append("null");
       } else {
         sb.append(this.extent);
       }
       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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.validate();
       }
       if (extent != null) {
         extent.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, ClassNotFoundException {
       try {
         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 loadTablet_argsStandardSchemeFactory implements SchemeFactory {
       public loadTablet_argsStandardScheme getScheme() {
         return new loadTablet_argsStandardScheme();
       }
     }
 
     private static class loadTablet_argsStandardScheme extends StandardScheme<loadTablet_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, loadTablet_args 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 5: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 4: // LOCK
               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                 struct.lock = iprot.readString();
                 struct.setLockIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // EXTENT
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.extent = new org.apache.accumulo.core.data.thrift.TKeyExtent();
                 struct.extent.read(iprot);
                 struct.setExtentIsSet(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, loadTablet_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.extent != null) {
           oprot.writeFieldBegin(EXTENT_FIELD_DESC);
           struct.extent.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.lock != null) {
           oprot.writeFieldBegin(LOCK_FIELD_DESC);
           oprot.writeString(struct.lock);
           oprot.writeFieldEnd();
         }
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class loadTablet_argsTupleSchemeFactory implements SchemeFactory {
       public loadTablet_argsTupleScheme getScheme() {
         return new loadTablet_argsTupleScheme();
       }
     }
 
     private static class loadTablet_argsTupleScheme extends TupleScheme<loadTablet_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, loadTablet_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         if (struct.isSetLock()) {
           optionals.set(2);
         }
         if (struct.isSetExtent()) {
           optionals.set(3);
         }
         oprot.writeBitSet(optionals, 4);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
         if (struct.isSetLock()) {
           oprot.writeString(struct.lock);
         }
         if (struct.isSetExtent()) {
           struct.extent.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, loadTablet_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(4);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
         if (incoming.get(2)) {
           struct.lock = iprot.readString();
           struct.setLockIsSet(true);
         }
         if (incoming.get(3)) {
           struct.extent = new org.apache.accumulo.core.data.thrift.TKeyExtent();
           struct.extent.read(iprot);
           struct.setExtentIsSet(true);
         }
       }
     }
 
   }
 
   public static class unloadTablet_args implements org.apache.thrift.TBase<unloadTablet_args, unloadTablet_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("unloadTablet_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)5);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField LOCK_FIELD_DESC = new org.apache.thrift.protocol.TField("lock", org.apache.thrift.protocol.TType.STRING, (short)4);
     private static final org.apache.thrift.protocol.TField EXTENT_FIELD_DESC = new org.apache.thrift.protocol.TField("extent", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField SAVE_FIELD_DESC = new org.apache.thrift.protocol.TField("save", org.apache.thrift.protocol.TType.BOOL, (short)3);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new unloadTablet_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new unloadTablet_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
     public String lock; // required
     public org.apache.accumulo.core.data.thrift.TKeyExtent extent; // required
     public boolean save; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)5, "tinfo"),
       CREDENTIAL((short)1, "credential"),
       LOCK((short)4, "lock"),
       EXTENT((short)2, "extent"),
       SAVE((short)3, "save");
 
       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 5: // TINFO
             return TINFO;
           case 1: // CREDENTIAL
             return CREDENTIAL;
           case 4: // LOCK
             return LOCK;
           case 2: // EXTENT
             return EXTENT;
           case 3: // SAVE
             return SAVE;
           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 __SAVE_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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       tmpMap.put(_Fields.LOCK, new org.apache.thrift.meta_data.FieldMetaData("lock", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
       tmpMap.put(_Fields.EXTENT, new org.apache.thrift.meta_data.FieldMetaData("extent", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.data.thrift.TKeyExtent.class)));
       tmpMap.put(_Fields.SAVE, new org.apache.thrift.meta_data.FieldMetaData("save", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(unloadTablet_args.class, metaDataMap);
     }
 
     public unloadTablet_args() {
     }
 
     public unloadTablet_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential,
       String lock,
       org.apache.accumulo.core.data.thrift.TKeyExtent extent,
       boolean save)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
       this.lock = lock;
       this.extent = extent;
       this.save = save;
       setSaveIsSet(true);
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public unloadTablet_args(unloadTablet_args other) {
       __isset_bitfield = other.__isset_bitfield;
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
       if (other.isSetLock()) {
         this.lock = other.lock;
       }
       if (other.isSetExtent()) {
         this.extent = new org.apache.accumulo.core.data.thrift.TKeyExtent(other.extent);
       }
       this.save = other.save;
     }
 
     public unloadTablet_args deepCopy() {
       return new unloadTablet_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
       this.lock = null;
       this.extent = null;
       setSaveIsSet(false);
       this.save = false;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public unloadTablet_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public unloadTablet_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public String getLock() {
       return this.lock;
     }
 
     public unloadTablet_args setLock(String lock) {
       this.lock = lock;
       return this;
     }
 
     public void unsetLock() {
       this.lock = null;
     }
 
     /** Returns true if field lock is set (has been assigned a value) and false otherwise */
     public boolean isSetLock() {
       return this.lock != null;
     }
 
     public void setLockIsSet(boolean value) {
       if (!value) {
         this.lock = null;
       }
     }
 
     public org.apache.accumulo.core.data.thrift.TKeyExtent getExtent() {
       return this.extent;
     }
 
     public unloadTablet_args setExtent(org.apache.accumulo.core.data.thrift.TKeyExtent extent) {
       this.extent = extent;
       return this;
     }
 
     public void unsetExtent() {
       this.extent = null;
     }
 
     /** Returns true if field extent is set (has been assigned a value) and false otherwise */
     public boolean isSetExtent() {
       return this.extent != null;
     }
 
     public void setExtentIsSet(boolean value) {
       if (!value) {
         this.extent = null;
       }
     }
 
     public boolean isSave() {
       return this.save;
     }
 
     public unloadTablet_args setSave(boolean save) {
       this.save = save;
       setSaveIsSet(true);
       return this;
     }
 
     public void unsetSave() {
       __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SAVE_ISSET_ID);
     }
 
     /** Returns true if field save is set (has been assigned a value) and false otherwise */
     public boolean isSetSave() {
       return EncodingUtils.testBit(__isset_bitfield, __SAVE_ISSET_ID);
     }
 
     public void setSaveIsSet(boolean value) {
       __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SAVE_ISSET_ID, value);
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       case LOCK:
         if (value == null) {
           unsetLock();
         } else {
           setLock((String)value);
         }
         break;
 
       case EXTENT:
         if (value == null) {
           unsetExtent();
         } else {
           setExtent((org.apache.accumulo.core.data.thrift.TKeyExtent)value);
         }
         break;
 
       case SAVE:
         if (value == null) {
           unsetSave();
         } else {
           setSave((Boolean)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       case LOCK:
         return getLock();
 
       case EXTENT:
         return getExtent();
 
       case SAVE:
         return Boolean.valueOf(isSave());
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       case LOCK:
         return isSetLock();
       case EXTENT:
         return isSetExtent();
       case SAVE:
         return isSetSave();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof unloadTablet_args)
         return this.equals((unloadTablet_args)that);
       return false;
     }
 
     public boolean equals(unloadTablet_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       boolean this_present_lock = true && this.isSetLock();
       boolean that_present_lock = true && that.isSetLock();
       if (this_present_lock || that_present_lock) {
         if (!(this_present_lock && that_present_lock))
           return false;
         if (!this.lock.equals(that.lock))
           return false;
       }
 
       boolean this_present_extent = true && this.isSetExtent();
       boolean that_present_extent = true && that.isSetExtent();
       if (this_present_extent || that_present_extent) {
         if (!(this_present_extent && that_present_extent))
           return false;
         if (!this.extent.equals(that.extent))
           return false;
       }
 
       boolean this_present_save = true;
       boolean that_present_save = true;
       if (this_present_save || that_present_save) {
         if (!(this_present_save && that_present_save))
           return false;
         if (this.save != that.save)
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(unloadTablet_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       unloadTablet_args typedOther = (unloadTablet_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetLock()).compareTo(typedOther.isSetLock());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetLock()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lock, typedOther.lock);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetExtent()).compareTo(typedOther.isSetExtent());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetExtent()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extent, typedOther.extent);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetSave()).compareTo(typedOther.isSetSave());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSave()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.save, typedOther.save);
         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("unloadTablet_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("lock:");
       if (this.lock == null) {
         sb.append("null");
       } else {
         sb.append(this.lock);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("extent:");
       if (this.extent == null) {
         sb.append("null");
       } else {
         sb.append(this.extent);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("save:");
       sb.append(this.save);
       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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.validate();
       }
       if (extent != null) {
         extent.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, 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 unloadTablet_argsStandardSchemeFactory implements SchemeFactory {
       public unloadTablet_argsStandardScheme getScheme() {
         return new unloadTablet_argsStandardScheme();
       }
     }
 
     private static class unloadTablet_argsStandardScheme extends StandardScheme<unloadTablet_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, unloadTablet_args 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 5: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 4: // LOCK
               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                 struct.lock = iprot.readString();
                 struct.setLockIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // EXTENT
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.extent = new org.apache.accumulo.core.data.thrift.TKeyExtent();
                 struct.extent.read(iprot);
                 struct.setExtentIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 3: // SAVE
               if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
                 struct.save = iprot.readBool();
                 struct.setSaveIsSet(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, unloadTablet_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.extent != null) {
           oprot.writeFieldBegin(EXTENT_FIELD_DESC);
           struct.extent.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldBegin(SAVE_FIELD_DESC);
         oprot.writeBool(struct.save);
         oprot.writeFieldEnd();
         if (struct.lock != null) {
           oprot.writeFieldBegin(LOCK_FIELD_DESC);
           oprot.writeString(struct.lock);
           oprot.writeFieldEnd();
         }
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class unloadTablet_argsTupleSchemeFactory implements SchemeFactory {
       public unloadTablet_argsTupleScheme getScheme() {
         return new unloadTablet_argsTupleScheme();
       }
     }
 
     private static class unloadTablet_argsTupleScheme extends TupleScheme<unloadTablet_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, unloadTablet_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         if (struct.isSetLock()) {
           optionals.set(2);
         }
         if (struct.isSetExtent()) {
           optionals.set(3);
         }
         if (struct.isSetSave()) {
           optionals.set(4);
         }
         oprot.writeBitSet(optionals, 5);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
         if (struct.isSetLock()) {
           oprot.writeString(struct.lock);
         }
         if (struct.isSetExtent()) {
           struct.extent.write(oprot);
         }
         if (struct.isSetSave()) {
           oprot.writeBool(struct.save);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, unloadTablet_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(5);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
         if (incoming.get(2)) {
           struct.lock = iprot.readString();
           struct.setLockIsSet(true);
         }
         if (incoming.get(3)) {
           struct.extent = new org.apache.accumulo.core.data.thrift.TKeyExtent();
           struct.extent.read(iprot);
           struct.setExtentIsSet(true);
         }
         if (incoming.get(4)) {
           struct.save = iprot.readBool();
           struct.setSaveIsSet(true);
         }
       }
     }
 
   }
 
   public static class flush_args implements org.apache.thrift.TBase<flush_args, flush_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("flush_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)4);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField LOCK_FIELD_DESC = new org.apache.thrift.protocol.TField("lock", org.apache.thrift.protocol.TType.STRING, (short)3);
     private static final org.apache.thrift.protocol.TField TABLE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("tableId", org.apache.thrift.protocol.TType.STRING, (short)2);
     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)5);
     private static final org.apache.thrift.protocol.TField END_ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("endRow", org.apache.thrift.protocol.TType.STRING, (short)6);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new flush_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new flush_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
     public String lock; // required
     public String tableId; // required
     public ByteBuffer startRow; // required
     public ByteBuffer endRow; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)4, "tinfo"),
       CREDENTIAL((short)1, "credential"),
       LOCK((short)3, "lock"),
       TABLE_ID((short)2, "tableId"),
       START_ROW((short)5, "startRow"),
       END_ROW((short)6, "endRow");
 
       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 4: // TINFO
             return TINFO;
           case 1: // CREDENTIAL
             return CREDENTIAL;
           case 3: // LOCK
             return LOCK;
           case 2: // TABLE_ID
             return TABLE_ID;
           case 5: // START_ROW
             return START_ROW;
           case 6: // END_ROW
             return END_ROW;
           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
     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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       tmpMap.put(_Fields.LOCK, new org.apache.thrift.meta_data.FieldMetaData("lock", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
       tmpMap.put(_Fields.TABLE_ID, new org.apache.thrift.meta_data.FieldMetaData("tableId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
       tmpMap.put(_Fields.START_ROW, new org.apache.thrift.meta_data.FieldMetaData("startRow", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
       tmpMap.put(_Fields.END_ROW, new org.apache.thrift.meta_data.FieldMetaData("endRow", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(flush_args.class, metaDataMap);
     }
 
     public flush_args() {
     }
 
     public flush_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential,
       String lock,
       String tableId,
       ByteBuffer startRow,
       ByteBuffer endRow)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
       this.lock = lock;
       this.tableId = tableId;
       this.startRow = startRow;
       this.endRow = endRow;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public flush_args(flush_args other) {
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
       if (other.isSetLock()) {
         this.lock = other.lock;
       }
       if (other.isSetTableId()) {
         this.tableId = other.tableId;
       }
       if (other.isSetStartRow()) {
         this.startRow = org.apache.thrift.TBaseHelper.copyBinary(other.startRow);
 ;
       }
       if (other.isSetEndRow()) {
         this.endRow = org.apache.thrift.TBaseHelper.copyBinary(other.endRow);
 ;
       }
     }
 
     public flush_args deepCopy() {
       return new flush_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
       this.lock = null;
       this.tableId = null;
       this.startRow = null;
       this.endRow = null;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public flush_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public flush_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public String getLock() {
       return this.lock;
     }
 
     public flush_args setLock(String lock) {
       this.lock = lock;
       return this;
     }
 
     public void unsetLock() {
       this.lock = null;
     }
 
     /** Returns true if field lock is set (has been assigned a value) and false otherwise */
     public boolean isSetLock() {
       return this.lock != null;
     }
 
     public void setLockIsSet(boolean value) {
       if (!value) {
         this.lock = null;
       }
     }
 
     public String getTableId() {
       return this.tableId;
     }
 
     public flush_args setTableId(String tableId) {
       this.tableId = tableId;
       return this;
     }
 
     public void unsetTableId() {
       this.tableId = null;
     }
 
     /** Returns true if field tableId is set (has been assigned a value) and false otherwise */
     public boolean isSetTableId() {
       return this.tableId != null;
     }
 
     public void setTableIdIsSet(boolean value) {
       if (!value) {
         this.tableId = null;
       }
     }
 
     public byte[] getStartRow() {
       setStartRow(org.apache.thrift.TBaseHelper.rightSize(startRow));
       return startRow == null ? null : startRow.array();
     }
 
     public ByteBuffer bufferForStartRow() {
       return startRow;
     }
 
     public flush_args setStartRow(byte[] startRow) {
       setStartRow(startRow == null ? (ByteBuffer)null : ByteBuffer.wrap(startRow));
       return this;
     }
 
     public flush_args setStartRow(ByteBuffer startRow) {
       this.startRow = 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[] getEndRow() {
       setEndRow(org.apache.thrift.TBaseHelper.rightSize(endRow));
       return endRow == null ? null : endRow.array();
     }
 
     public ByteBuffer bufferForEndRow() {
       return endRow;
     }
 
     public flush_args setEndRow(byte[] endRow) {
       setEndRow(endRow == null ? (ByteBuffer)null : ByteBuffer.wrap(endRow));
       return this;
     }
 
     public flush_args setEndRow(ByteBuffer endRow) {
       this.endRow = endRow;
       return this;
     }
 
     public void unsetEndRow() {
       this.endRow = null;
     }
 
     /** Returns true if field endRow is set (has been assigned a value) and false otherwise */
     public boolean isSetEndRow() {
       return this.endRow != null;
     }
 
     public void setEndRowIsSet(boolean value) {
       if (!value) {
         this.endRow = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       case LOCK:
         if (value == null) {
           unsetLock();
         } else {
           setLock((String)value);
         }
         break;
 
       case TABLE_ID:
         if (value == null) {
           unsetTableId();
         } else {
           setTableId((String)value);
         }
         break;
 
       case START_ROW:
         if (value == null) {
           unsetStartRow();
         } else {
           setStartRow((ByteBuffer)value);
         }
         break;
 
       case END_ROW:
         if (value == null) {
           unsetEndRow();
         } else {
           setEndRow((ByteBuffer)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       case LOCK:
         return getLock();
 
       case TABLE_ID:
         return getTableId();
 
       case START_ROW:
         return getStartRow();
 
       case END_ROW:
         return getEndRow();
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       case LOCK:
         return isSetLock();
       case TABLE_ID:
         return isSetTableId();
       case START_ROW:
         return isSetStartRow();
       case END_ROW:
         return isSetEndRow();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof flush_args)
         return this.equals((flush_args)that);
       return false;
     }
 
     public boolean equals(flush_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       boolean this_present_lock = true && this.isSetLock();
       boolean that_present_lock = true && that.isSetLock();
       if (this_present_lock || that_present_lock) {
         if (!(this_present_lock && that_present_lock))
           return false;
         if (!this.lock.equals(that.lock))
           return false;
       }
 
       boolean this_present_tableId = true && this.isSetTableId();
       boolean that_present_tableId = true && that.isSetTableId();
       if (this_present_tableId || that_present_tableId) {
         if (!(this_present_tableId && that_present_tableId))
           return false;
         if (!this.tableId.equals(that.tableId))
           return false;
       }
 
       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_endRow = true && this.isSetEndRow();
       boolean that_present_endRow = true && that.isSetEndRow();
       if (this_present_endRow || that_present_endRow) {
         if (!(this_present_endRow && that_present_endRow))
           return false;
         if (!this.endRow.equals(that.endRow))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(flush_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       flush_args typedOther = (flush_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetLock()).compareTo(typedOther.isSetLock());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetLock()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lock, typedOther.lock);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetTableId()).compareTo(typedOther.isSetTableId());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTableId()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableId, typedOther.tableId);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(typedOther.isSetStartRow());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetStartRow()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startRow, typedOther.startRow);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetEndRow()).compareTo(typedOther.isSetEndRow());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetEndRow()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.endRow, typedOther.endRow);
         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("flush_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("lock:");
       if (this.lock == null) {
         sb.append("null");
       } else {
         sb.append(this.lock);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("tableId:");
       if (this.tableId == null) {
         sb.append("null");
       } else {
         sb.append(this.tableId);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("startRow:");
       if (this.startRow == null) {
         sb.append("null");
       } else {
         org.apache.thrift.TBaseHelper.toString(this.startRow, sb);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("endRow:");
       if (this.endRow == null) {
         sb.append("null");
       } else {
         org.apache.thrift.TBaseHelper.toString(this.endRow, 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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.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, ClassNotFoundException {
       try {
         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 flush_argsStandardSchemeFactory implements SchemeFactory {
       public flush_argsStandardScheme getScheme() {
         return new flush_argsStandardScheme();
       }
     }
 
     private static class flush_argsStandardScheme extends StandardScheme<flush_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, flush_args 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 4: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 3: // LOCK
               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                 struct.lock = iprot.readString();
                 struct.setLockIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // TABLE_ID
               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                 struct.tableId = iprot.readString();
                 struct.setTableIdIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 5: // 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 6: // END_ROW
               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                 struct.endRow = iprot.readBinary();
                 struct.setEndRowIsSet(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, flush_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.tableId != null) {
           oprot.writeFieldBegin(TABLE_ID_FIELD_DESC);
           oprot.writeString(struct.tableId);
           oprot.writeFieldEnd();
         }
         if (struct.lock != null) {
           oprot.writeFieldBegin(LOCK_FIELD_DESC);
           oprot.writeString(struct.lock);
           oprot.writeFieldEnd();
         }
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.startRow != null) {
           oprot.writeFieldBegin(START_ROW_FIELD_DESC);
           oprot.writeBinary(struct.startRow);
           oprot.writeFieldEnd();
         }
         if (struct.endRow != null) {
           oprot.writeFieldBegin(END_ROW_FIELD_DESC);
           oprot.writeBinary(struct.endRow);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class flush_argsTupleSchemeFactory implements SchemeFactory {
       public flush_argsTupleScheme getScheme() {
         return new flush_argsTupleScheme();
       }
     }
 
     private static class flush_argsTupleScheme extends TupleScheme<flush_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, flush_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         if (struct.isSetLock()) {
           optionals.set(2);
         }
         if (struct.isSetTableId()) {
           optionals.set(3);
         }
         if (struct.isSetStartRow()) {
           optionals.set(4);
         }
         if (struct.isSetEndRow()) {
           optionals.set(5);
         }
         oprot.writeBitSet(optionals, 6);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
         if (struct.isSetLock()) {
           oprot.writeString(struct.lock);
         }
         if (struct.isSetTableId()) {
           oprot.writeString(struct.tableId);
         }
         if (struct.isSetStartRow()) {
           oprot.writeBinary(struct.startRow);
         }
         if (struct.isSetEndRow()) {
           oprot.writeBinary(struct.endRow);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, flush_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(6);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
         if (incoming.get(2)) {
           struct.lock = iprot.readString();
           struct.setLockIsSet(true);
         }
         if (incoming.get(3)) {
           struct.tableId = iprot.readString();
           struct.setTableIdIsSet(true);
         }
         if (incoming.get(4)) {
           struct.startRow = iprot.readBinary();
           struct.setStartRowIsSet(true);
         }
         if (incoming.get(5)) {
           struct.endRow = iprot.readBinary();
           struct.setEndRowIsSet(true);
         }
       }
     }
 
   }
 
   public static class flushTablet_args implements org.apache.thrift.TBase<flushTablet_args, flushTablet_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("flushTablet_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField LOCK_FIELD_DESC = new org.apache.thrift.protocol.TField("lock", org.apache.thrift.protocol.TType.STRING, (short)3);
     private static final org.apache.thrift.protocol.TField EXTENT_FIELD_DESC = new org.apache.thrift.protocol.TField("extent", org.apache.thrift.protocol.TType.STRUCT, (short)4);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new flushTablet_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new flushTablet_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
     public String lock; // required
     public org.apache.accumulo.core.data.thrift.TKeyExtent extent; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)1, "tinfo"),
       CREDENTIAL((short)2, "credential"),
       LOCK((short)3, "lock"),
       EXTENT((short)4, "extent");
 
       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: // TINFO
             return TINFO;
           case 2: // CREDENTIAL
             return CREDENTIAL;
           case 3: // LOCK
             return LOCK;
           case 4: // EXTENT
             return EXTENT;
           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
     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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       tmpMap.put(_Fields.LOCK, new org.apache.thrift.meta_data.FieldMetaData("lock", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
       tmpMap.put(_Fields.EXTENT, new org.apache.thrift.meta_data.FieldMetaData("extent", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.data.thrift.TKeyExtent.class)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(flushTablet_args.class, metaDataMap);
     }
 
     public flushTablet_args() {
     }
 
     public flushTablet_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential,
       String lock,
       org.apache.accumulo.core.data.thrift.TKeyExtent extent)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
       this.lock = lock;
       this.extent = extent;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public flushTablet_args(flushTablet_args other) {
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
       if (other.isSetLock()) {
         this.lock = other.lock;
       }
       if (other.isSetExtent()) {
         this.extent = new org.apache.accumulo.core.data.thrift.TKeyExtent(other.extent);
       }
     }
 
     public flushTablet_args deepCopy() {
       return new flushTablet_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
       this.lock = null;
       this.extent = null;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public flushTablet_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public flushTablet_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public String getLock() {
       return this.lock;
     }
 
     public flushTablet_args setLock(String lock) {
       this.lock = lock;
       return this;
     }
 
     public void unsetLock() {
       this.lock = null;
     }
 
     /** Returns true if field lock is set (has been assigned a value) and false otherwise */
     public boolean isSetLock() {
       return this.lock != null;
     }
 
     public void setLockIsSet(boolean value) {
       if (!value) {
         this.lock = null;
       }
     }
 
     public org.apache.accumulo.core.data.thrift.TKeyExtent getExtent() {
       return this.extent;
     }
 
     public flushTablet_args setExtent(org.apache.accumulo.core.data.thrift.TKeyExtent extent) {
       this.extent = extent;
       return this;
     }
 
     public void unsetExtent() {
       this.extent = null;
     }
 
     /** Returns true if field extent is set (has been assigned a value) and false otherwise */
     public boolean isSetExtent() {
       return this.extent != null;
     }
 
     public void setExtentIsSet(boolean value) {
       if (!value) {
         this.extent = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       case LOCK:
         if (value == null) {
           unsetLock();
         } else {
           setLock((String)value);
         }
         break;
 
       case EXTENT:
         if (value == null) {
           unsetExtent();
         } else {
           setExtent((org.apache.accumulo.core.data.thrift.TKeyExtent)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       case LOCK:
         return getLock();
 
       case EXTENT:
         return getExtent();
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       case LOCK:
         return isSetLock();
       case EXTENT:
         return isSetExtent();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof flushTablet_args)
         return this.equals((flushTablet_args)that);
       return false;
     }
 
     public boolean equals(flushTablet_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       boolean this_present_lock = true && this.isSetLock();
       boolean that_present_lock = true && that.isSetLock();
       if (this_present_lock || that_present_lock) {
         if (!(this_present_lock && that_present_lock))
           return false;
         if (!this.lock.equals(that.lock))
           return false;
       }
 
       boolean this_present_extent = true && this.isSetExtent();
       boolean that_present_extent = true && that.isSetExtent();
       if (this_present_extent || that_present_extent) {
         if (!(this_present_extent && that_present_extent))
           return false;
         if (!this.extent.equals(that.extent))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(flushTablet_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       flushTablet_args typedOther = (flushTablet_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetLock()).compareTo(typedOther.isSetLock());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetLock()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lock, typedOther.lock);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetExtent()).compareTo(typedOther.isSetExtent());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetExtent()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extent, typedOther.extent);
         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("flushTablet_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("lock:");
       if (this.lock == null) {
         sb.append("null");
       } else {
         sb.append(this.lock);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("extent:");
       if (this.extent == null) {
         sb.append("null");
       } else {
         sb.append(this.extent);
       }
       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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.validate();
       }
       if (extent != null) {
         extent.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, ClassNotFoundException {
       try {
         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 flushTablet_argsStandardSchemeFactory implements SchemeFactory {
       public flushTablet_argsStandardScheme getScheme() {
         return new flushTablet_argsStandardScheme();
       }
     }
 
     private static class flushTablet_argsStandardScheme extends StandardScheme<flushTablet_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, flushTablet_args 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: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 3: // LOCK
               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                 struct.lock = iprot.readString();
                 struct.setLockIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 4: // EXTENT
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.extent = new org.apache.accumulo.core.data.thrift.TKeyExtent();
                 struct.extent.read(iprot);
                 struct.setExtentIsSet(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, flushTablet_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.lock != null) {
           oprot.writeFieldBegin(LOCK_FIELD_DESC);
           oprot.writeString(struct.lock);
           oprot.writeFieldEnd();
         }
         if (struct.extent != null) {
           oprot.writeFieldBegin(EXTENT_FIELD_DESC);
           struct.extent.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class flushTablet_argsTupleSchemeFactory implements SchemeFactory {
       public flushTablet_argsTupleScheme getScheme() {
         return new flushTablet_argsTupleScheme();
       }
     }
 
     private static class flushTablet_argsTupleScheme extends TupleScheme<flushTablet_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, flushTablet_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         if (struct.isSetLock()) {
           optionals.set(2);
         }
         if (struct.isSetExtent()) {
           optionals.set(3);
         }
         oprot.writeBitSet(optionals, 4);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
         if (struct.isSetLock()) {
           oprot.writeString(struct.lock);
         }
         if (struct.isSetExtent()) {
           struct.extent.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, flushTablet_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(4);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
         if (incoming.get(2)) {
           struct.lock = iprot.readString();
           struct.setLockIsSet(true);
         }
         if (incoming.get(3)) {
           struct.extent = new org.apache.accumulo.core.data.thrift.TKeyExtent();
           struct.extent.read(iprot);
           struct.setExtentIsSet(true);
         }
       }
     }
 
   }
 
   public static class chop_args implements org.apache.thrift.TBase<chop_args, chop_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("chop_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField LOCK_FIELD_DESC = new org.apache.thrift.protocol.TField("lock", org.apache.thrift.protocol.TType.STRING, (short)3);
     private static final org.apache.thrift.protocol.TField EXTENT_FIELD_DESC = new org.apache.thrift.protocol.TField("extent", org.apache.thrift.protocol.TType.STRUCT, (short)4);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new chop_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new chop_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
     public String lock; // required
     public org.apache.accumulo.core.data.thrift.TKeyExtent extent; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)1, "tinfo"),
       CREDENTIAL((short)2, "credential"),
       LOCK((short)3, "lock"),
       EXTENT((short)4, "extent");
 
       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: // TINFO
             return TINFO;
           case 2: // CREDENTIAL
             return CREDENTIAL;
           case 3: // LOCK
             return LOCK;
           case 4: // EXTENT
             return EXTENT;
           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
     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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       tmpMap.put(_Fields.LOCK, new org.apache.thrift.meta_data.FieldMetaData("lock", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
       tmpMap.put(_Fields.EXTENT, new org.apache.thrift.meta_data.FieldMetaData("extent", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.data.thrift.TKeyExtent.class)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(chop_args.class, metaDataMap);
     }
 
     public chop_args() {
     }
 
     public chop_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential,
       String lock,
       org.apache.accumulo.core.data.thrift.TKeyExtent extent)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
       this.lock = lock;
       this.extent = extent;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public chop_args(chop_args other) {
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
       if (other.isSetLock()) {
         this.lock = other.lock;
       }
       if (other.isSetExtent()) {
         this.extent = new org.apache.accumulo.core.data.thrift.TKeyExtent(other.extent);
       }
     }
 
     public chop_args deepCopy() {
       return new chop_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
       this.lock = null;
       this.extent = null;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public chop_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public chop_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public String getLock() {
       return this.lock;
     }
 
     public chop_args setLock(String lock) {
       this.lock = lock;
       return this;
     }
 
     public void unsetLock() {
       this.lock = null;
     }
 
     /** Returns true if field lock is set (has been assigned a value) and false otherwise */
     public boolean isSetLock() {
       return this.lock != null;
     }
 
     public void setLockIsSet(boolean value) {
       if (!value) {
         this.lock = null;
       }
     }
 
     public org.apache.accumulo.core.data.thrift.TKeyExtent getExtent() {
       return this.extent;
     }
 
     public chop_args setExtent(org.apache.accumulo.core.data.thrift.TKeyExtent extent) {
       this.extent = extent;
       return this;
     }
 
     public void unsetExtent() {
       this.extent = null;
     }
 
     /** Returns true if field extent is set (has been assigned a value) and false otherwise */
     public boolean isSetExtent() {
       return this.extent != null;
     }
 
     public void setExtentIsSet(boolean value) {
       if (!value) {
         this.extent = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       case LOCK:
         if (value == null) {
           unsetLock();
         } else {
           setLock((String)value);
         }
         break;
 
       case EXTENT:
         if (value == null) {
           unsetExtent();
         } else {
           setExtent((org.apache.accumulo.core.data.thrift.TKeyExtent)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       case LOCK:
         return getLock();
 
       case EXTENT:
         return getExtent();
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       case LOCK:
         return isSetLock();
       case EXTENT:
         return isSetExtent();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof chop_args)
         return this.equals((chop_args)that);
       return false;
     }
 
     public boolean equals(chop_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       boolean this_present_lock = true && this.isSetLock();
       boolean that_present_lock = true && that.isSetLock();
       if (this_present_lock || that_present_lock) {
         if (!(this_present_lock && that_present_lock))
           return false;
         if (!this.lock.equals(that.lock))
           return false;
       }
 
       boolean this_present_extent = true && this.isSetExtent();
       boolean that_present_extent = true && that.isSetExtent();
       if (this_present_extent || that_present_extent) {
         if (!(this_present_extent && that_present_extent))
           return false;
         if (!this.extent.equals(that.extent))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(chop_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       chop_args typedOther = (chop_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetLock()).compareTo(typedOther.isSetLock());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetLock()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lock, typedOther.lock);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetExtent()).compareTo(typedOther.isSetExtent());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetExtent()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extent, typedOther.extent);
         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("chop_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("lock:");
       if (this.lock == null) {
         sb.append("null");
       } else {
         sb.append(this.lock);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("extent:");
       if (this.extent == null) {
         sb.append("null");
       } else {
         sb.append(this.extent);
       }
       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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.validate();
       }
       if (extent != null) {
         extent.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, ClassNotFoundException {
       try {
         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 chop_argsStandardSchemeFactory implements SchemeFactory {
       public chop_argsStandardScheme getScheme() {
         return new chop_argsStandardScheme();
       }
     }
 
     private static class chop_argsStandardScheme extends StandardScheme<chop_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, chop_args 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: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 3: // LOCK
               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                 struct.lock = iprot.readString();
                 struct.setLockIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 4: // EXTENT
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.extent = new org.apache.accumulo.core.data.thrift.TKeyExtent();
                 struct.extent.read(iprot);
                 struct.setExtentIsSet(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, chop_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.lock != null) {
           oprot.writeFieldBegin(LOCK_FIELD_DESC);
           oprot.writeString(struct.lock);
           oprot.writeFieldEnd();
         }
         if (struct.extent != null) {
           oprot.writeFieldBegin(EXTENT_FIELD_DESC);
           struct.extent.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class chop_argsTupleSchemeFactory implements SchemeFactory {
       public chop_argsTupleScheme getScheme() {
         return new chop_argsTupleScheme();
       }
     }
 
     private static class chop_argsTupleScheme extends TupleScheme<chop_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, chop_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         if (struct.isSetLock()) {
           optionals.set(2);
         }
         if (struct.isSetExtent()) {
           optionals.set(3);
         }
         oprot.writeBitSet(optionals, 4);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
         if (struct.isSetLock()) {
           oprot.writeString(struct.lock);
         }
         if (struct.isSetExtent()) {
           struct.extent.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, chop_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(4);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
         if (incoming.get(2)) {
           struct.lock = iprot.readString();
           struct.setLockIsSet(true);
         }
         if (incoming.get(3)) {
           struct.extent = new org.apache.accumulo.core.data.thrift.TKeyExtent();
           struct.extent.read(iprot);
           struct.setExtentIsSet(true);
         }
       }
     }
 
   }
 
   public static class compact_args implements org.apache.thrift.TBase<compact_args, compact_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("compact_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField LOCK_FIELD_DESC = new org.apache.thrift.protocol.TField("lock", org.apache.thrift.protocol.TType.STRING, (short)3);
     private static final org.apache.thrift.protocol.TField TABLE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("tableId", org.apache.thrift.protocol.TType.STRING, (short)4);
     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)5);
     private static final org.apache.thrift.protocol.TField END_ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("endRow", org.apache.thrift.protocol.TType.STRING, (short)6);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new compact_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new compact_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
     public String lock; // required
     public String tableId; // required
     public ByteBuffer startRow; // required
     public ByteBuffer endRow; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)1, "tinfo"),
       CREDENTIAL((short)2, "credential"),
       LOCK((short)3, "lock"),
       TABLE_ID((short)4, "tableId"),
       START_ROW((short)5, "startRow"),
       END_ROW((short)6, "endRow");
 
       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: // TINFO
             return TINFO;
           case 2: // CREDENTIAL
             return CREDENTIAL;
           case 3: // LOCK
             return LOCK;
           case 4: // TABLE_ID
             return TABLE_ID;
           case 5: // START_ROW
             return START_ROW;
           case 6: // END_ROW
             return END_ROW;
           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
     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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       tmpMap.put(_Fields.LOCK, new org.apache.thrift.meta_data.FieldMetaData("lock", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
       tmpMap.put(_Fields.TABLE_ID, new org.apache.thrift.meta_data.FieldMetaData("tableId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
       tmpMap.put(_Fields.START_ROW, new org.apache.thrift.meta_data.FieldMetaData("startRow", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
       tmpMap.put(_Fields.END_ROW, new org.apache.thrift.meta_data.FieldMetaData("endRow", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(compact_args.class, metaDataMap);
     }
 
     public compact_args() {
     }
 
     public compact_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential,
       String lock,
       String tableId,
       ByteBuffer startRow,
       ByteBuffer endRow)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
       this.lock = lock;
       this.tableId = tableId;
       this.startRow = startRow;
       this.endRow = endRow;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public compact_args(compact_args other) {
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
       if (other.isSetLock()) {
         this.lock = other.lock;
       }
       if (other.isSetTableId()) {
         this.tableId = other.tableId;
       }
       if (other.isSetStartRow()) {
         this.startRow = org.apache.thrift.TBaseHelper.copyBinary(other.startRow);
 ;
       }
       if (other.isSetEndRow()) {
         this.endRow = org.apache.thrift.TBaseHelper.copyBinary(other.endRow);
 ;
       }
     }
 
     public compact_args deepCopy() {
       return new compact_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
       this.lock = null;
       this.tableId = null;
       this.startRow = null;
       this.endRow = null;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public compact_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public compact_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public String getLock() {
       return this.lock;
     }
 
     public compact_args setLock(String lock) {
       this.lock = lock;
       return this;
     }
 
     public void unsetLock() {
       this.lock = null;
     }
 
     /** Returns true if field lock is set (has been assigned a value) and false otherwise */
     public boolean isSetLock() {
       return this.lock != null;
     }
 
     public void setLockIsSet(boolean value) {
       if (!value) {
         this.lock = null;
       }
     }
 
     public String getTableId() {
       return this.tableId;
     }
 
     public compact_args setTableId(String tableId) {
       this.tableId = tableId;
       return this;
     }
 
     public void unsetTableId() {
       this.tableId = null;
     }
 
     /** Returns true if field tableId is set (has been assigned a value) and false otherwise */
     public boolean isSetTableId() {
       return this.tableId != null;
     }
 
     public void setTableIdIsSet(boolean value) {
       if (!value) {
         this.tableId = null;
       }
     }
 
     public byte[] getStartRow() {
       setStartRow(org.apache.thrift.TBaseHelper.rightSize(startRow));
       return startRow == null ? null : startRow.array();
     }
 
     public ByteBuffer bufferForStartRow() {
       return startRow;
     }
 
     public compact_args setStartRow(byte[] startRow) {
       setStartRow(startRow == null ? (ByteBuffer)null : ByteBuffer.wrap(startRow));
       return this;
     }
 
     public compact_args setStartRow(ByteBuffer startRow) {
       this.startRow = 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[] getEndRow() {
       setEndRow(org.apache.thrift.TBaseHelper.rightSize(endRow));
       return endRow == null ? null : endRow.array();
     }
 
     public ByteBuffer bufferForEndRow() {
       return endRow;
     }
 
     public compact_args setEndRow(byte[] endRow) {
       setEndRow(endRow == null ? (ByteBuffer)null : ByteBuffer.wrap(endRow));
       return this;
     }
 
     public compact_args setEndRow(ByteBuffer endRow) {
       this.endRow = endRow;
       return this;
     }
 
     public void unsetEndRow() {
       this.endRow = null;
     }
 
     /** Returns true if field endRow is set (has been assigned a value) and false otherwise */
     public boolean isSetEndRow() {
       return this.endRow != null;
     }
 
     public void setEndRowIsSet(boolean value) {
       if (!value) {
         this.endRow = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       case LOCK:
         if (value == null) {
           unsetLock();
         } else {
           setLock((String)value);
         }
         break;
 
       case TABLE_ID:
         if (value == null) {
           unsetTableId();
         } else {
           setTableId((String)value);
         }
         break;
 
       case START_ROW:
         if (value == null) {
           unsetStartRow();
         } else {
           setStartRow((ByteBuffer)value);
         }
         break;
 
       case END_ROW:
         if (value == null) {
           unsetEndRow();
         } else {
           setEndRow((ByteBuffer)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       case LOCK:
         return getLock();
 
       case TABLE_ID:
         return getTableId();
 
       case START_ROW:
         return getStartRow();
 
       case END_ROW:
         return getEndRow();
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       case LOCK:
         return isSetLock();
       case TABLE_ID:
         return isSetTableId();
       case START_ROW:
         return isSetStartRow();
       case END_ROW:
         return isSetEndRow();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof compact_args)
         return this.equals((compact_args)that);
       return false;
     }
 
     public boolean equals(compact_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       boolean this_present_lock = true && this.isSetLock();
       boolean that_present_lock = true && that.isSetLock();
       if (this_present_lock || that_present_lock) {
         if (!(this_present_lock && that_present_lock))
           return false;
         if (!this.lock.equals(that.lock))
           return false;
       }
 
       boolean this_present_tableId = true && this.isSetTableId();
       boolean that_present_tableId = true && that.isSetTableId();
       if (this_present_tableId || that_present_tableId) {
         if (!(this_present_tableId && that_present_tableId))
           return false;
         if (!this.tableId.equals(that.tableId))
           return false;
       }
 
       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_endRow = true && this.isSetEndRow();
       boolean that_present_endRow = true && that.isSetEndRow();
       if (this_present_endRow || that_present_endRow) {
         if (!(this_present_endRow && that_present_endRow))
           return false;
         if (!this.endRow.equals(that.endRow))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(compact_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       compact_args typedOther = (compact_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetLock()).compareTo(typedOther.isSetLock());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetLock()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lock, typedOther.lock);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetTableId()).compareTo(typedOther.isSetTableId());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTableId()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableId, typedOther.tableId);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(typedOther.isSetStartRow());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetStartRow()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startRow, typedOther.startRow);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetEndRow()).compareTo(typedOther.isSetEndRow());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetEndRow()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.endRow, typedOther.endRow);
         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("compact_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("lock:");
       if (this.lock == null) {
         sb.append("null");
       } else {
         sb.append(this.lock);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("tableId:");
       if (this.tableId == null) {
         sb.append("null");
       } else {
         sb.append(this.tableId);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("startRow:");
       if (this.startRow == null) {
         sb.append("null");
       } else {
         org.apache.thrift.TBaseHelper.toString(this.startRow, sb);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("endRow:");
       if (this.endRow == null) {
         sb.append("null");
       } else {
         org.apache.thrift.TBaseHelper.toString(this.endRow, 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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.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, ClassNotFoundException {
       try {
         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 compact_argsStandardSchemeFactory implements SchemeFactory {
       public compact_argsStandardScheme getScheme() {
         return new compact_argsStandardScheme();
       }
     }
 
     private static class compact_argsStandardScheme extends StandardScheme<compact_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, compact_args 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: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 3: // LOCK
               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                 struct.lock = iprot.readString();
                 struct.setLockIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 4: // TABLE_ID
               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                 struct.tableId = iprot.readString();
                 struct.setTableIdIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 5: // 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 6: // END_ROW
               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                 struct.endRow = iprot.readBinary();
                 struct.setEndRowIsSet(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, compact_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.lock != null) {
           oprot.writeFieldBegin(LOCK_FIELD_DESC);
           oprot.writeString(struct.lock);
           oprot.writeFieldEnd();
         }
         if (struct.tableId != null) {
           oprot.writeFieldBegin(TABLE_ID_FIELD_DESC);
           oprot.writeString(struct.tableId);
           oprot.writeFieldEnd();
         }
         if (struct.startRow != null) {
           oprot.writeFieldBegin(START_ROW_FIELD_DESC);
           oprot.writeBinary(struct.startRow);
           oprot.writeFieldEnd();
         }
         if (struct.endRow != null) {
           oprot.writeFieldBegin(END_ROW_FIELD_DESC);
           oprot.writeBinary(struct.endRow);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class compact_argsTupleSchemeFactory implements SchemeFactory {
       public compact_argsTupleScheme getScheme() {
         return new compact_argsTupleScheme();
       }
     }
 
     private static class compact_argsTupleScheme extends TupleScheme<compact_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, compact_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         if (struct.isSetLock()) {
           optionals.set(2);
         }
         if (struct.isSetTableId()) {
           optionals.set(3);
         }
         if (struct.isSetStartRow()) {
           optionals.set(4);
         }
         if (struct.isSetEndRow()) {
           optionals.set(5);
         }
         oprot.writeBitSet(optionals, 6);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
         if (struct.isSetLock()) {
           oprot.writeString(struct.lock);
         }
         if (struct.isSetTableId()) {
           oprot.writeString(struct.tableId);
         }
         if (struct.isSetStartRow()) {
           oprot.writeBinary(struct.startRow);
         }
         if (struct.isSetEndRow()) {
           oprot.writeBinary(struct.endRow);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, compact_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(6);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
         if (incoming.get(2)) {
           struct.lock = iprot.readString();
           struct.setLockIsSet(true);
         }
         if (incoming.get(3)) {
           struct.tableId = iprot.readString();
           struct.setTableIdIsSet(true);
         }
         if (incoming.get(4)) {
           struct.startRow = iprot.readBinary();
           struct.setStartRowIsSet(true);
         }
         if (incoming.get(5)) {
           struct.endRow = iprot.readBinary();
           struct.setEndRowIsSet(true);
         }
       }
     }
 
   }
 
   public static class getTabletServerStatus_args implements org.apache.thrift.TBase<getTabletServerStatus_args, getTabletServerStatus_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTabletServerStatus_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)3);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new getTabletServerStatus_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new getTabletServerStatus_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)3, "tinfo"),
       CREDENTIAL((short)1, "credential");
 
       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 3: // TINFO
             return TINFO;
           case 1: // CREDENTIAL
             return CREDENTIAL;
           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
     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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTabletServerStatus_args.class, metaDataMap);
     }
 
     public getTabletServerStatus_args() {
     }
 
     public getTabletServerStatus_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public getTabletServerStatus_args(getTabletServerStatus_args other) {
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
     }
 
     public getTabletServerStatus_args deepCopy() {
       return new getTabletServerStatus_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public getTabletServerStatus_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public getTabletServerStatus_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof getTabletServerStatus_args)
         return this.equals((getTabletServerStatus_args)that);
       return false;
     }
 
     public boolean equals(getTabletServerStatus_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(getTabletServerStatus_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       getTabletServerStatus_args typedOther = (getTabletServerStatus_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         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("getTabletServerStatus_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.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, ClassNotFoundException {
       try {
         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 getTabletServerStatus_argsStandardSchemeFactory implements SchemeFactory {
       public getTabletServerStatus_argsStandardScheme getScheme() {
         return new getTabletServerStatus_argsStandardScheme();
       }
     }
 
     private static class getTabletServerStatus_argsStandardScheme extends StandardScheme<getTabletServerStatus_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, getTabletServerStatus_args 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 3: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(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, getTabletServerStatus_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class getTabletServerStatus_argsTupleSchemeFactory implements SchemeFactory {
       public getTabletServerStatus_argsTupleScheme getScheme() {
         return new getTabletServerStatus_argsTupleScheme();
       }
     }
 
     private static class getTabletServerStatus_argsTupleScheme extends TupleScheme<getTabletServerStatus_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, getTabletServerStatus_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, getTabletServerStatus_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
       }
     }
 
   }
 
   public static class getTabletServerStatus_result implements org.apache.thrift.TBase<getTabletServerStatus_result, getTabletServerStatus_result._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTabletServerStatus_result");
 
     private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
     private static final org.apache.thrift.protocol.TField SEC_FIELD_DESC = new org.apache.thrift.protocol.TField("sec", org.apache.thrift.protocol.TType.STRUCT, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new getTabletServerStatus_resultStandardSchemeFactory());
       schemes.put(TupleScheme.class, new getTabletServerStatus_resultTupleSchemeFactory());
     }
 
     public org.apache.accumulo.core.master.thrift.TabletServerStatus success; // required
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException sec; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       SUCCESS((short)0, "success"),
       SEC((short)1, "sec");
 
       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 0: // SUCCESS
             return SUCCESS;
           case 1: // SEC
             return SEC;
           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
     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.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.master.thrift.TabletServerStatus.class)));
       tmpMap.put(_Fields.SEC, new org.apache.thrift.meta_data.FieldMetaData("sec", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTabletServerStatus_result.class, metaDataMap);
     }
 
     public getTabletServerStatus_result() {
     }
 
     public getTabletServerStatus_result(
       org.apache.accumulo.core.master.thrift.TabletServerStatus success,
       org.apache.accumulo.core.security.thrift.ThriftSecurityException sec)
     {
       this();
       this.success = success;
       this.sec = sec;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public getTabletServerStatus_result(getTabletServerStatus_result other) {
       if (other.isSetSuccess()) {
         this.success = new org.apache.accumulo.core.master.thrift.TabletServerStatus(other.success);
       }
       if (other.isSetSec()) {
         this.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException(other.sec);
       }
     }
 
     public getTabletServerStatus_result deepCopy() {
       return new getTabletServerStatus_result(this);
     }
 
     @Override
     public void clear() {
       this.success = null;
       this.sec = null;
     }
 
     public org.apache.accumulo.core.master.thrift.TabletServerStatus getSuccess() {
       return this.success;
     }
 
     public getTabletServerStatus_result setSuccess(org.apache.accumulo.core.master.thrift.TabletServerStatus success) {
       this.success = success;
       return this;
     }
 
     public void unsetSuccess() {
       this.success = null;
     }
 
     /** Returns true if field success is set (has been assigned a value) and false otherwise */
     public boolean isSetSuccess() {
       return this.success != null;
     }
 
     public void setSuccessIsSet(boolean value) {
       if (!value) {
         this.success = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException getSec() {
       return this.sec;
     }
 
     public getTabletServerStatus_result setSec(org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
       this.sec = sec;
       return this;
     }
 
     public void unsetSec() {
       this.sec = null;
     }
 
     /** Returns true if field sec is set (has been assigned a value) and false otherwise */
     public boolean isSetSec() {
       return this.sec != null;
     }
 
     public void setSecIsSet(boolean value) {
       if (!value) {
         this.sec = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
           setSuccess((org.apache.accumulo.core.master.thrift.TabletServerStatus)value);
         }
         break;
 
       case SEC:
         if (value == null) {
           unsetSec();
         } else {
           setSec((org.apache.accumulo.core.security.thrift.ThriftSecurityException)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
         return getSuccess();
 
       case SEC:
         return getSec();
 
       }
       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 SUCCESS:
         return isSetSuccess();
       case SEC:
         return isSetSec();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof getTabletServerStatus_result)
         return this.equals((getTabletServerStatus_result)that);
       return false;
     }
 
     public boolean equals(getTabletServerStatus_result that) {
       if (that == null)
         return false;
 
       boolean this_present_success = true && this.isSetSuccess();
       boolean that_present_success = true && that.isSetSuccess();
       if (this_present_success || that_present_success) {
         if (!(this_present_success && that_present_success))
           return false;
         if (!this.success.equals(that.success))
           return false;
       }
 
       boolean this_present_sec = true && this.isSetSec();
       boolean that_present_sec = true && that.isSetSec();
       if (this_present_sec || that_present_sec) {
         if (!(this_present_sec && that_present_sec))
           return false;
         if (!this.sec.equals(that.sec))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(getTabletServerStatus_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       getTabletServerStatus_result typedOther = (getTabletServerStatus_result)other;
 
       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSuccess()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetSec()).compareTo(typedOther.isSetSec());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSec()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sec, typedOther.sec);
         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("getTabletServerStatus_result(");
       boolean first = true;
 
       sb.append("success:");
       if (this.success == null) {
         sb.append("null");
       } else {
         sb.append(this.success);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("sec:");
       if (this.sec == null) {
         sb.append("null");
       } else {
         sb.append(this.sec);
       }
       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 (success != null) {
         success.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, ClassNotFoundException {
       try {
         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 getTabletServerStatus_resultStandardSchemeFactory implements SchemeFactory {
       public getTabletServerStatus_resultStandardScheme getScheme() {
         return new getTabletServerStatus_resultStandardScheme();
       }
     }
 
     private static class getTabletServerStatus_resultStandardScheme extends StandardScheme<getTabletServerStatus_result> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, getTabletServerStatus_result 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 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.success = new org.apache.accumulo.core.master.thrift.TabletServerStatus();
                 struct.success.read(iprot);
                 struct.setSuccessIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // SEC
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
                 struct.sec.read(iprot);
                 struct.setSecIsSet(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, getTabletServerStatus_result struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.success != null) {
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           struct.success.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.sec != null) {
           oprot.writeFieldBegin(SEC_FIELD_DESC);
           struct.sec.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class getTabletServerStatus_resultTupleSchemeFactory implements SchemeFactory {
       public getTabletServerStatus_resultTupleScheme getScheme() {
         return new getTabletServerStatus_resultTupleScheme();
       }
     }
 
     private static class getTabletServerStatus_resultTupleScheme extends TupleScheme<getTabletServerStatus_result> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, getTabletServerStatus_result struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetSuccess()) {
           optionals.set(0);
         }
         if (struct.isSetSec()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetSuccess()) {
           struct.success.write(oprot);
         }
         if (struct.isSetSec()) {
           struct.sec.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, getTabletServerStatus_result struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           struct.success = new org.apache.accumulo.core.master.thrift.TabletServerStatus();
           struct.success.read(iprot);
           struct.setSuccessIsSet(true);
         }
         if (incoming.get(1)) {
           struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
           struct.sec.read(iprot);
           struct.setSecIsSet(true);
         }
       }
     }
 
   }
 
   public static class getTabletStats_args implements org.apache.thrift.TBase<getTabletStats_args, getTabletStats_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTabletStats_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)3);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField TABLE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("tableId", org.apache.thrift.protocol.TType.STRING, (short)2);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new getTabletStats_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new getTabletStats_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
     public String tableId; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)3, "tinfo"),
       CREDENTIAL((short)1, "credential"),
       TABLE_ID((short)2, "tableId");
 
       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 3: // TINFO
             return TINFO;
           case 1: // CREDENTIAL
             return CREDENTIAL;
           case 2: // TABLE_ID
             return TABLE_ID;
           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
     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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       tmpMap.put(_Fields.TABLE_ID, new org.apache.thrift.meta_data.FieldMetaData("tableId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTabletStats_args.class, metaDataMap);
     }
 
     public getTabletStats_args() {
     }
 
     public getTabletStats_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential,
       String tableId)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
       this.tableId = tableId;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public getTabletStats_args(getTabletStats_args other) {
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
       if (other.isSetTableId()) {
         this.tableId = other.tableId;
       }
     }
 
     public getTabletStats_args deepCopy() {
       return new getTabletStats_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
       this.tableId = null;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public getTabletStats_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public getTabletStats_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public String getTableId() {
       return this.tableId;
     }
 
     public getTabletStats_args setTableId(String tableId) {
       this.tableId = tableId;
       return this;
     }
 
     public void unsetTableId() {
       this.tableId = null;
     }
 
     /** Returns true if field tableId is set (has been assigned a value) and false otherwise */
     public boolean isSetTableId() {
       return this.tableId != null;
     }
 
     public void setTableIdIsSet(boolean value) {
       if (!value) {
         this.tableId = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       case TABLE_ID:
         if (value == null) {
           unsetTableId();
         } else {
           setTableId((String)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       case TABLE_ID:
         return getTableId();
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       case TABLE_ID:
         return isSetTableId();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof getTabletStats_args)
         return this.equals((getTabletStats_args)that);
       return false;
     }
 
     public boolean equals(getTabletStats_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       boolean this_present_tableId = true && this.isSetTableId();
       boolean that_present_tableId = true && that.isSetTableId();
       if (this_present_tableId || that_present_tableId) {
         if (!(this_present_tableId && that_present_tableId))
           return false;
         if (!this.tableId.equals(that.tableId))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(getTabletStats_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       getTabletStats_args typedOther = (getTabletStats_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetTableId()).compareTo(typedOther.isSetTableId());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTableId()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableId, typedOther.tableId);
         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("getTabletStats_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("tableId:");
       if (this.tableId == null) {
         sb.append("null");
       } else {
         sb.append(this.tableId);
       }
       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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.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, ClassNotFoundException {
       try {
         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 getTabletStats_argsStandardSchemeFactory implements SchemeFactory {
       public getTabletStats_argsStandardScheme getScheme() {
         return new getTabletStats_argsStandardScheme();
       }
     }
 
     private static class getTabletStats_argsStandardScheme extends StandardScheme<getTabletStats_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, getTabletStats_args 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 3: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // TABLE_ID
               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                 struct.tableId = iprot.readString();
                 struct.setTableIdIsSet(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, getTabletStats_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.tableId != null) {
           oprot.writeFieldBegin(TABLE_ID_FIELD_DESC);
           oprot.writeString(struct.tableId);
           oprot.writeFieldEnd();
         }
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class getTabletStats_argsTupleSchemeFactory implements SchemeFactory {
       public getTabletStats_argsTupleScheme getScheme() {
         return new getTabletStats_argsTupleScheme();
       }
     }
 
     private static class getTabletStats_argsTupleScheme extends TupleScheme<getTabletStats_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, getTabletStats_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         if (struct.isSetTableId()) {
           optionals.set(2);
         }
         oprot.writeBitSet(optionals, 3);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
         if (struct.isSetTableId()) {
           oprot.writeString(struct.tableId);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, getTabletStats_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(3);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
         if (incoming.get(2)) {
           struct.tableId = iprot.readString();
           struct.setTableIdIsSet(true);
         }
       }
     }
 
   }
 
   public static class getTabletStats_result implements org.apache.thrift.TBase<getTabletStats_result, getTabletStats_result._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTabletStats_result");
 
     private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
     private static final org.apache.thrift.protocol.TField SEC_FIELD_DESC = new org.apache.thrift.protocol.TField("sec", org.apache.thrift.protocol.TType.STRUCT, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new getTabletStats_resultStandardSchemeFactory());
       schemes.put(TupleScheme.class, new getTabletStats_resultTupleSchemeFactory());
     }
 
     public List<TabletStats> success; // required
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException sec; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       SUCCESS((short)0, "success"),
       SEC((short)1, "sec");
 
       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 0: // SUCCESS
             return SUCCESS;
           case 1: // SEC
             return SEC;
           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
     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.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           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, TabletStats.class))));
       tmpMap.put(_Fields.SEC, new org.apache.thrift.meta_data.FieldMetaData("sec", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTabletStats_result.class, metaDataMap);
     }
 
     public getTabletStats_result() {
     }
 
     public getTabletStats_result(
       List<TabletStats> success,
       org.apache.accumulo.core.security.thrift.ThriftSecurityException sec)
     {
       this();
       this.success = success;
       this.sec = sec;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public getTabletStats_result(getTabletStats_result other) {
       if (other.isSetSuccess()) {
         List<TabletStats> __this__success = new ArrayList<TabletStats>();
         for (TabletStats other_element : other.success) {
           __this__success.add(new TabletStats(other_element));
         }
         this.success = __this__success;
       }
       if (other.isSetSec()) {
         this.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException(other.sec);
       }
     }
 
     public getTabletStats_result deepCopy() {
       return new getTabletStats_result(this);
     }
 
     @Override
     public void clear() {
       this.success = null;
       this.sec = null;
     }
 
     public int getSuccessSize() {
       return (this.success == null) ? 0 : this.success.size();
     }
 
     public java.util.Iterator<TabletStats> getSuccessIterator() {
       return (this.success == null) ? null : this.success.iterator();
     }
 
     public void addToSuccess(TabletStats elem) {
       if (this.success == null) {
         this.success = new ArrayList<TabletStats>();
       }
       this.success.add(elem);
     }
 
     public List<TabletStats> getSuccess() {
       return this.success;
     }
 
     public getTabletStats_result setSuccess(List<TabletStats> success) {
       this.success = success;
       return this;
     }
 
     public void unsetSuccess() {
       this.success = null;
     }
 
     /** Returns true if field success is set (has been assigned a value) and false otherwise */
     public boolean isSetSuccess() {
       return this.success != null;
     }
 
     public void setSuccessIsSet(boolean value) {
       if (!value) {
         this.success = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException getSec() {
       return this.sec;
     }
 
     public getTabletStats_result setSec(org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
       this.sec = sec;
       return this;
     }
 
     public void unsetSec() {
       this.sec = null;
     }
 
     /** Returns true if field sec is set (has been assigned a value) and false otherwise */
     public boolean isSetSec() {
       return this.sec != null;
     }
 
     public void setSecIsSet(boolean value) {
       if (!value) {
         this.sec = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
           setSuccess((List<TabletStats>)value);
         }
         break;
 
       case SEC:
         if (value == null) {
           unsetSec();
         } else {
           setSec((org.apache.accumulo.core.security.thrift.ThriftSecurityException)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
         return getSuccess();
 
       case SEC:
         return getSec();
 
       }
       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 SUCCESS:
         return isSetSuccess();
       case SEC:
         return isSetSec();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof getTabletStats_result)
         return this.equals((getTabletStats_result)that);
       return false;
     }
 
     public boolean equals(getTabletStats_result that) {
       if (that == null)
         return false;
 
       boolean this_present_success = true && this.isSetSuccess();
       boolean that_present_success = true && that.isSetSuccess();
       if (this_present_success || that_present_success) {
         if (!(this_present_success && that_present_success))
           return false;
         if (!this.success.equals(that.success))
           return false;
       }
 
       boolean this_present_sec = true && this.isSetSec();
       boolean that_present_sec = true && that.isSetSec();
       if (this_present_sec || that_present_sec) {
         if (!(this_present_sec && that_present_sec))
           return false;
         if (!this.sec.equals(that.sec))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(getTabletStats_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       getTabletStats_result typedOther = (getTabletStats_result)other;
 
       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSuccess()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetSec()).compareTo(typedOther.isSetSec());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSec()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sec, typedOther.sec);
         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("getTabletStats_result(");
       boolean first = true;
 
       sb.append("success:");
       if (this.success == null) {
         sb.append("null");
       } else {
         sb.append(this.success);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("sec:");
       if (this.sec == null) {
         sb.append("null");
       } else {
         sb.append(this.sec);
       }
       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 {
         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 getTabletStats_resultStandardSchemeFactory implements SchemeFactory {
       public getTabletStats_resultStandardScheme getScheme() {
         return new getTabletStats_resultStandardScheme();
       }
     }
 
     private static class getTabletStats_resultStandardScheme extends StandardScheme<getTabletStats_result> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, getTabletStats_result 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 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                 {
                   org.apache.thrift.protocol.TList _list248 = iprot.readListBegin();
                   struct.success = new ArrayList<TabletStats>(_list248.size);
                   for (int _i249 = 0; _i249 < _list248.size; ++_i249)
                   {
                     TabletStats _elem250; // required
                     _elem250 = new TabletStats();
                     _elem250.read(iprot);
                     struct.success.add(_elem250);
                   }
                   iprot.readListEnd();
                 }
                 struct.setSuccessIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // SEC
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
                 struct.sec.read(iprot);
                 struct.setSecIsSet(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, getTabletStats_result struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.success != null) {
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
             for (TabletStats _iter251 : struct.success)
             {
               _iter251.write(oprot);
             }
             oprot.writeListEnd();
           }
           oprot.writeFieldEnd();
         }
         if (struct.sec != null) {
           oprot.writeFieldBegin(SEC_FIELD_DESC);
           struct.sec.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class getTabletStats_resultTupleSchemeFactory implements SchemeFactory {
       public getTabletStats_resultTupleScheme getScheme() {
         return new getTabletStats_resultTupleScheme();
       }
     }
 
     private static class getTabletStats_resultTupleScheme extends TupleScheme<getTabletStats_result> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, getTabletStats_result struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetSuccess()) {
           optionals.set(0);
         }
         if (struct.isSetSec()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetSuccess()) {
           {
             oprot.writeI32(struct.success.size());
             for (TabletStats _iter252 : struct.success)
             {
               _iter252.write(oprot);
             }
           }
         }
         if (struct.isSetSec()) {
           struct.sec.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, getTabletStats_result struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           {
             org.apache.thrift.protocol.TList _list253 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
             struct.success = new ArrayList<TabletStats>(_list253.size);
             for (int _i254 = 0; _i254 < _list253.size; ++_i254)
             {
               TabletStats _elem255; // required
               _elem255 = new TabletStats();
               _elem255.read(iprot);
               struct.success.add(_elem255);
             }
           }
           struct.setSuccessIsSet(true);
         }
         if (incoming.get(1)) {
           struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
           struct.sec.read(iprot);
           struct.setSecIsSet(true);
         }
       }
     }
 
   }
 
   public static class getHistoricalStats_args implements org.apache.thrift.TBase<getHistoricalStats_args, getHistoricalStats_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getHistoricalStats_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new getHistoricalStats_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new getHistoricalStats_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)2, "tinfo"),
       CREDENTIAL((short)1, "credential");
 
       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 2: // TINFO
             return TINFO;
           case 1: // CREDENTIAL
             return CREDENTIAL;
           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
     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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getHistoricalStats_args.class, metaDataMap);
     }
 
     public getHistoricalStats_args() {
     }
 
     public getHistoricalStats_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public getHistoricalStats_args(getHistoricalStats_args other) {
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
     }
 
     public getHistoricalStats_args deepCopy() {
       return new getHistoricalStats_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public getHistoricalStats_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public getHistoricalStats_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof getHistoricalStats_args)
         return this.equals((getHistoricalStats_args)that);
       return false;
     }
 
     public boolean equals(getHistoricalStats_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(getHistoricalStats_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       getHistoricalStats_args typedOther = (getHistoricalStats_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         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("getHistoricalStats_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.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, ClassNotFoundException {
       try {
         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 getHistoricalStats_argsStandardSchemeFactory implements SchemeFactory {
       public getHistoricalStats_argsStandardScheme getScheme() {
         return new getHistoricalStats_argsStandardScheme();
       }
     }
 
     private static class getHistoricalStats_argsStandardScheme extends StandardScheme<getHistoricalStats_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, getHistoricalStats_args 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 2: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(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, getHistoricalStats_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class getHistoricalStats_argsTupleSchemeFactory implements SchemeFactory {
       public getHistoricalStats_argsTupleScheme getScheme() {
         return new getHistoricalStats_argsTupleScheme();
       }
     }
 
     private static class getHistoricalStats_argsTupleScheme extends TupleScheme<getHistoricalStats_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, getHistoricalStats_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, getHistoricalStats_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
       }
     }
 
   }
 
   public static class getHistoricalStats_result implements org.apache.thrift.TBase<getHistoricalStats_result, getHistoricalStats_result._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getHistoricalStats_result");
 
     private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
     private static final org.apache.thrift.protocol.TField SEC_FIELD_DESC = new org.apache.thrift.protocol.TField("sec", org.apache.thrift.protocol.TType.STRUCT, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new getHistoricalStats_resultStandardSchemeFactory());
       schemes.put(TupleScheme.class, new getHistoricalStats_resultTupleSchemeFactory());
     }
 
     public TabletStats success; // required
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException sec; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       SUCCESS((short)0, "success"),
       SEC((short)1, "sec");
 
       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 0: // SUCCESS
             return SUCCESS;
           case 1: // SEC
             return SEC;
           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
     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.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TabletStats.class)));
       tmpMap.put(_Fields.SEC, new org.apache.thrift.meta_data.FieldMetaData("sec", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getHistoricalStats_result.class, metaDataMap);
     }
 
     public getHistoricalStats_result() {
     }
 
     public getHistoricalStats_result(
       TabletStats success,
       org.apache.accumulo.core.security.thrift.ThriftSecurityException sec)
     {
       this();
       this.success = success;
       this.sec = sec;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public getHistoricalStats_result(getHistoricalStats_result other) {
       if (other.isSetSuccess()) {
         this.success = new TabletStats(other.success);
       }
       if (other.isSetSec()) {
         this.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException(other.sec);
       }
     }
 
     public getHistoricalStats_result deepCopy() {
       return new getHistoricalStats_result(this);
     }
 
     @Override
     public void clear() {
       this.success = null;
       this.sec = null;
     }
 
     public TabletStats getSuccess() {
       return this.success;
     }
 
     public getHistoricalStats_result setSuccess(TabletStats success) {
       this.success = success;
       return this;
     }
 
     public void unsetSuccess() {
       this.success = null;
     }
 
     /** Returns true if field success is set (has been assigned a value) and false otherwise */
     public boolean isSetSuccess() {
       return this.success != null;
     }
 
     public void setSuccessIsSet(boolean value) {
       if (!value) {
         this.success = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException getSec() {
       return this.sec;
     }
 
     public getHistoricalStats_result setSec(org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
       this.sec = sec;
       return this;
     }
 
     public void unsetSec() {
       this.sec = null;
     }
 
     /** Returns true if field sec is set (has been assigned a value) and false otherwise */
     public boolean isSetSec() {
       return this.sec != null;
     }
 
     public void setSecIsSet(boolean value) {
       if (!value) {
         this.sec = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
           setSuccess((TabletStats)value);
         }
         break;
 
       case SEC:
         if (value == null) {
           unsetSec();
         } else {
           setSec((org.apache.accumulo.core.security.thrift.ThriftSecurityException)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
         return getSuccess();
 
       case SEC:
         return getSec();
 
       }
       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 SUCCESS:
         return isSetSuccess();
       case SEC:
         return isSetSec();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof getHistoricalStats_result)
         return this.equals((getHistoricalStats_result)that);
       return false;
     }
 
     public boolean equals(getHistoricalStats_result that) {
       if (that == null)
         return false;
 
       boolean this_present_success = true && this.isSetSuccess();
       boolean that_present_success = true && that.isSetSuccess();
       if (this_present_success || that_present_success) {
         if (!(this_present_success && that_present_success))
           return false;
         if (!this.success.equals(that.success))
           return false;
       }
 
       boolean this_present_sec = true && this.isSetSec();
       boolean that_present_sec = true && that.isSetSec();
       if (this_present_sec || that_present_sec) {
         if (!(this_present_sec && that_present_sec))
           return false;
         if (!this.sec.equals(that.sec))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(getHistoricalStats_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       getHistoricalStats_result typedOther = (getHistoricalStats_result)other;
 
       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSuccess()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetSec()).compareTo(typedOther.isSetSec());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSec()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sec, typedOther.sec);
         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("getHistoricalStats_result(");
       boolean first = true;
 
       sb.append("success:");
       if (this.success == null) {
         sb.append("null");
       } else {
         sb.append(this.success);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("sec:");
       if (this.sec == null) {
         sb.append("null");
       } else {
         sb.append(this.sec);
       }
       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 (success != null) {
         success.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, ClassNotFoundException {
       try {
         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 getHistoricalStats_resultStandardSchemeFactory implements SchemeFactory {
       public getHistoricalStats_resultStandardScheme getScheme() {
         return new getHistoricalStats_resultStandardScheme();
       }
     }
 
     private static class getHistoricalStats_resultStandardScheme extends StandardScheme<getHistoricalStats_result> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, getHistoricalStats_result 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 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.success = new TabletStats();
                 struct.success.read(iprot);
                 struct.setSuccessIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // SEC
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
                 struct.sec.read(iprot);
                 struct.setSecIsSet(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, getHistoricalStats_result struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.success != null) {
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           struct.success.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.sec != null) {
           oprot.writeFieldBegin(SEC_FIELD_DESC);
           struct.sec.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class getHistoricalStats_resultTupleSchemeFactory implements SchemeFactory {
       public getHistoricalStats_resultTupleScheme getScheme() {
         return new getHistoricalStats_resultTupleScheme();
       }
     }
 
     private static class getHistoricalStats_resultTupleScheme extends TupleScheme<getHistoricalStats_result> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, getHistoricalStats_result struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetSuccess()) {
           optionals.set(0);
         }
         if (struct.isSetSec()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetSuccess()) {
           struct.success.write(oprot);
         }
         if (struct.isSetSec()) {
           struct.sec.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, getHistoricalStats_result struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           struct.success = new TabletStats();
           struct.success.read(iprot);
           struct.setSuccessIsSet(true);
         }
         if (incoming.get(1)) {
           struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
           struct.sec.read(iprot);
           struct.setSecIsSet(true);
         }
       }
     }
 
   }
 
   public static class halt_args implements org.apache.thrift.TBase<halt_args, halt_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("halt_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)3);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField LOCK_FIELD_DESC = new org.apache.thrift.protocol.TField("lock", org.apache.thrift.protocol.TType.STRING, (short)2);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new halt_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new halt_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
     public String lock; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)3, "tinfo"),
       CREDENTIAL((short)1, "credential"),
       LOCK((short)2, "lock");
 
       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 3: // TINFO
             return TINFO;
           case 1: // CREDENTIAL
             return CREDENTIAL;
           case 2: // LOCK
             return LOCK;
           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
     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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       tmpMap.put(_Fields.LOCK, new org.apache.thrift.meta_data.FieldMetaData("lock", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(halt_args.class, metaDataMap);
     }
 
     public halt_args() {
     }
 
     public halt_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential,
       String lock)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
       this.lock = lock;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public halt_args(halt_args other) {
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
       if (other.isSetLock()) {
         this.lock = other.lock;
       }
     }
 
     public halt_args deepCopy() {
       return new halt_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
       this.lock = null;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public halt_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public halt_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public String getLock() {
       return this.lock;
     }
 
     public halt_args setLock(String lock) {
       this.lock = lock;
       return this;
     }
 
     public void unsetLock() {
       this.lock = null;
     }
 
     /** Returns true if field lock is set (has been assigned a value) and false otherwise */
     public boolean isSetLock() {
       return this.lock != null;
     }
 
     public void setLockIsSet(boolean value) {
       if (!value) {
         this.lock = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       case LOCK:
         if (value == null) {
           unsetLock();
         } else {
           setLock((String)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       case LOCK:
         return getLock();
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       case LOCK:
         return isSetLock();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof halt_args)
         return this.equals((halt_args)that);
       return false;
     }
 
     public boolean equals(halt_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       boolean this_present_lock = true && this.isSetLock();
       boolean that_present_lock = true && that.isSetLock();
       if (this_present_lock || that_present_lock) {
         if (!(this_present_lock && that_present_lock))
           return false;
         if (!this.lock.equals(that.lock))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(halt_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       halt_args typedOther = (halt_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetLock()).compareTo(typedOther.isSetLock());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetLock()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lock, typedOther.lock);
         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("halt_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("lock:");
       if (this.lock == null) {
         sb.append("null");
       } else {
         sb.append(this.lock);
       }
       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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.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, ClassNotFoundException {
       try {
         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 halt_argsStandardSchemeFactory implements SchemeFactory {
       public halt_argsStandardScheme getScheme() {
         return new halt_argsStandardScheme();
       }
     }
 
     private static class halt_argsStandardScheme extends StandardScheme<halt_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, halt_args 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 3: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // LOCK
               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                 struct.lock = iprot.readString();
                 struct.setLockIsSet(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, halt_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.lock != null) {
           oprot.writeFieldBegin(LOCK_FIELD_DESC);
           oprot.writeString(struct.lock);
           oprot.writeFieldEnd();
         }
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class halt_argsTupleSchemeFactory implements SchemeFactory {
       public halt_argsTupleScheme getScheme() {
         return new halt_argsTupleScheme();
       }
     }
 
     private static class halt_argsTupleScheme extends TupleScheme<halt_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, halt_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         if (struct.isSetLock()) {
           optionals.set(2);
         }
         oprot.writeBitSet(optionals, 3);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
         if (struct.isSetLock()) {
           oprot.writeString(struct.lock);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, halt_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(3);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
         if (incoming.get(2)) {
           struct.lock = iprot.readString();
           struct.setLockIsSet(true);
         }
       }
     }
 
   }
 
   public static class halt_result implements org.apache.thrift.TBase<halt_result, halt_result._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("halt_result");
 
     private static final org.apache.thrift.protocol.TField SEC_FIELD_DESC = new org.apache.thrift.protocol.TField("sec", org.apache.thrift.protocol.TType.STRUCT, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new halt_resultStandardSchemeFactory());
       schemes.put(TupleScheme.class, new halt_resultTupleSchemeFactory());
     }
 
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException sec; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       SEC((short)1, "sec");
 
       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: // SEC
             return SEC;
           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
     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.SEC, new org.apache.thrift.meta_data.FieldMetaData("sec", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(halt_result.class, metaDataMap);
     }
 
     public halt_result() {
     }
 
     public halt_result(
       org.apache.accumulo.core.security.thrift.ThriftSecurityException sec)
     {
       this();
       this.sec = sec;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public halt_result(halt_result other) {
       if (other.isSetSec()) {
         this.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException(other.sec);
       }
     }
 
     public halt_result deepCopy() {
       return new halt_result(this);
     }
 
     @Override
     public void clear() {
       this.sec = null;
     }
 
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException getSec() {
       return this.sec;
     }
 
     public halt_result setSec(org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
       this.sec = sec;
       return this;
     }
 
     public void unsetSec() {
       this.sec = null;
     }
 
     /** Returns true if field sec is set (has been assigned a value) and false otherwise */
     public boolean isSetSec() {
       return this.sec != null;
     }
 
     public void setSecIsSet(boolean value) {
       if (!value) {
         this.sec = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SEC:
         if (value == null) {
           unsetSec();
         } else {
           setSec((org.apache.accumulo.core.security.thrift.ThriftSecurityException)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SEC:
         return getSec();
 
       }
       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 SEC:
         return isSetSec();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof halt_result)
         return this.equals((halt_result)that);
       return false;
     }
 
     public boolean equals(halt_result that) {
       if (that == null)
         return false;
 
       boolean this_present_sec = true && this.isSetSec();
       boolean that_present_sec = true && that.isSetSec();
       if (this_present_sec || that_present_sec) {
         if (!(this_present_sec && that_present_sec))
           return false;
         if (!this.sec.equals(that.sec))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(halt_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       halt_result typedOther = (halt_result)other;
 
       lastComparison = Boolean.valueOf(isSetSec()).compareTo(typedOther.isSetSec());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSec()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sec, typedOther.sec);
         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("halt_result(");
       boolean first = true;
 
       sb.append("sec:");
       if (this.sec == null) {
         sb.append("null");
       } else {
         sb.append(this.sec);
       }
       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 {
         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 halt_resultStandardSchemeFactory implements SchemeFactory {
       public halt_resultStandardScheme getScheme() {
         return new halt_resultStandardScheme();
       }
     }
 
     private static class halt_resultStandardScheme extends StandardScheme<halt_result> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, halt_result 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: // SEC
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
                 struct.sec.read(iprot);
                 struct.setSecIsSet(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, halt_result struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.sec != null) {
           oprot.writeFieldBegin(SEC_FIELD_DESC);
           struct.sec.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class halt_resultTupleSchemeFactory implements SchemeFactory {
       public halt_resultTupleScheme getScheme() {
         return new halt_resultTupleScheme();
       }
     }
 
     private static class halt_resultTupleScheme extends TupleScheme<halt_result> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, halt_result struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetSec()) {
           optionals.set(0);
         }
         oprot.writeBitSet(optionals, 1);
         if (struct.isSetSec()) {
           struct.sec.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, halt_result struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(1);
         if (incoming.get(0)) {
           struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
           struct.sec.read(iprot);
           struct.setSecIsSet(true);
         }
       }
     }
 
   }
 
   public static class fastHalt_args implements org.apache.thrift.TBase<fastHalt_args, fastHalt_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("fastHalt_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)3);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField LOCK_FIELD_DESC = new org.apache.thrift.protocol.TField("lock", org.apache.thrift.protocol.TType.STRING, (short)2);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new fastHalt_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new fastHalt_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
     public String lock; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)3, "tinfo"),
       CREDENTIAL((short)1, "credential"),
       LOCK((short)2, "lock");
 
       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 3: // TINFO
             return TINFO;
           case 1: // CREDENTIAL
             return CREDENTIAL;
           case 2: // LOCK
             return LOCK;
           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
     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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       tmpMap.put(_Fields.LOCK, new org.apache.thrift.meta_data.FieldMetaData("lock", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(fastHalt_args.class, metaDataMap);
     }
 
     public fastHalt_args() {
     }
 
     public fastHalt_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential,
       String lock)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
       this.lock = lock;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public fastHalt_args(fastHalt_args other) {
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
       if (other.isSetLock()) {
         this.lock = other.lock;
       }
     }
 
     public fastHalt_args deepCopy() {
       return new fastHalt_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
       this.lock = null;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public fastHalt_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public fastHalt_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public String getLock() {
       return this.lock;
     }
 
     public fastHalt_args setLock(String lock) {
       this.lock = lock;
       return this;
     }
 
     public void unsetLock() {
       this.lock = null;
     }
 
     /** Returns true if field lock is set (has been assigned a value) and false otherwise */
     public boolean isSetLock() {
       return this.lock != null;
     }
 
     public void setLockIsSet(boolean value) {
       if (!value) {
         this.lock = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       case LOCK:
         if (value == null) {
           unsetLock();
         } else {
           setLock((String)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       case LOCK:
         return getLock();
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       case LOCK:
         return isSetLock();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof fastHalt_args)
         return this.equals((fastHalt_args)that);
       return false;
     }
 
     public boolean equals(fastHalt_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       boolean this_present_lock = true && this.isSetLock();
       boolean that_present_lock = true && that.isSetLock();
       if (this_present_lock || that_present_lock) {
         if (!(this_present_lock && that_present_lock))
           return false;
         if (!this.lock.equals(that.lock))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(fastHalt_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       fastHalt_args typedOther = (fastHalt_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetLock()).compareTo(typedOther.isSetLock());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetLock()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lock, typedOther.lock);
         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("fastHalt_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("lock:");
       if (this.lock == null) {
         sb.append("null");
       } else {
         sb.append(this.lock);
       }
       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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.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, ClassNotFoundException {
       try {
         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 fastHalt_argsStandardSchemeFactory implements SchemeFactory {
       public fastHalt_argsStandardScheme getScheme() {
         return new fastHalt_argsStandardScheme();
       }
     }
 
     private static class fastHalt_argsStandardScheme extends StandardScheme<fastHalt_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, fastHalt_args 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 3: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // LOCK
               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                 struct.lock = iprot.readString();
                 struct.setLockIsSet(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, fastHalt_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.lock != null) {
           oprot.writeFieldBegin(LOCK_FIELD_DESC);
           oprot.writeString(struct.lock);
           oprot.writeFieldEnd();
         }
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class fastHalt_argsTupleSchemeFactory implements SchemeFactory {
       public fastHalt_argsTupleScheme getScheme() {
         return new fastHalt_argsTupleScheme();
       }
     }
 
     private static class fastHalt_argsTupleScheme extends TupleScheme<fastHalt_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, fastHalt_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         if (struct.isSetLock()) {
           optionals.set(2);
         }
         oprot.writeBitSet(optionals, 3);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
         if (struct.isSetLock()) {
           oprot.writeString(struct.lock);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, fastHalt_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(3);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
         if (incoming.get(2)) {
           struct.lock = iprot.readString();
           struct.setLockIsSet(true);
         }
       }
     }
 
   }
 
   public static class getActiveScans_args implements org.apache.thrift.TBase<getActiveScans_args, getActiveScans_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getActiveScans_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new getActiveScans_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new getActiveScans_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)2, "tinfo"),
       CREDENTIAL((short)1, "credential");
 
       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 2: // TINFO
             return TINFO;
           case 1: // CREDENTIAL
             return CREDENTIAL;
           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
     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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getActiveScans_args.class, metaDataMap);
     }
 
     public getActiveScans_args() {
     }
 
     public getActiveScans_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public getActiveScans_args(getActiveScans_args other) {
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
     }
 
     public getActiveScans_args deepCopy() {
       return new getActiveScans_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public getActiveScans_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public getActiveScans_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof getActiveScans_args)
         return this.equals((getActiveScans_args)that);
       return false;
     }
 
     public boolean equals(getActiveScans_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(getActiveScans_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       getActiveScans_args typedOther = (getActiveScans_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         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("getActiveScans_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.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, ClassNotFoundException {
       try {
         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 getActiveScans_argsStandardSchemeFactory implements SchemeFactory {
       public getActiveScans_argsStandardScheme getScheme() {
         return new getActiveScans_argsStandardScheme();
       }
     }
 
     private static class getActiveScans_argsStandardScheme extends StandardScheme<getActiveScans_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, getActiveScans_args 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 2: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(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, getActiveScans_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class getActiveScans_argsTupleSchemeFactory implements SchemeFactory {
       public getActiveScans_argsTupleScheme getScheme() {
         return new getActiveScans_argsTupleScheme();
       }
     }
 
     private static class getActiveScans_argsTupleScheme extends TupleScheme<getActiveScans_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, getActiveScans_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, getActiveScans_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
       }
     }
 
   }
 
   public static class getActiveScans_result implements org.apache.thrift.TBase<getActiveScans_result, getActiveScans_result._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getActiveScans_result");
 
     private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
     private static final org.apache.thrift.protocol.TField SEC_FIELD_DESC = new org.apache.thrift.protocol.TField("sec", org.apache.thrift.protocol.TType.STRUCT, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new getActiveScans_resultStandardSchemeFactory());
       schemes.put(TupleScheme.class, new getActiveScans_resultTupleSchemeFactory());
     }
 
     public List<ActiveScan> success; // required
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException sec; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       SUCCESS((short)0, "success"),
       SEC((short)1, "sec");
 
       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 0: // SUCCESS
             return SUCCESS;
           case 1: // SEC
             return SEC;
           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
     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.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           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, ActiveScan.class))));
       tmpMap.put(_Fields.SEC, new org.apache.thrift.meta_data.FieldMetaData("sec", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getActiveScans_result.class, metaDataMap);
     }
 
     public getActiveScans_result() {
     }
 
     public getActiveScans_result(
       List<ActiveScan> success,
       org.apache.accumulo.core.security.thrift.ThriftSecurityException sec)
     {
       this();
       this.success = success;
       this.sec = sec;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public getActiveScans_result(getActiveScans_result other) {
       if (other.isSetSuccess()) {
         List<ActiveScan> __this__success = new ArrayList<ActiveScan>();
         for (ActiveScan other_element : other.success) {
           __this__success.add(new ActiveScan(other_element));
         }
         this.success = __this__success;
       }
       if (other.isSetSec()) {
         this.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException(other.sec);
       }
     }
 
     public getActiveScans_result deepCopy() {
       return new getActiveScans_result(this);
     }
 
     @Override
     public void clear() {
       this.success = null;
       this.sec = null;
     }
 
     public int getSuccessSize() {
       return (this.success == null) ? 0 : this.success.size();
     }
 
     public java.util.Iterator<ActiveScan> getSuccessIterator() {
       return (this.success == null) ? null : this.success.iterator();
     }
 
     public void addToSuccess(ActiveScan elem) {
       if (this.success == null) {
         this.success = new ArrayList<ActiveScan>();
       }
       this.success.add(elem);
     }
 
     public List<ActiveScan> getSuccess() {
       return this.success;
     }
 
     public getActiveScans_result setSuccess(List<ActiveScan> success) {
       this.success = success;
       return this;
     }
 
     public void unsetSuccess() {
       this.success = null;
     }
 
     /** Returns true if field success is set (has been assigned a value) and false otherwise */
     public boolean isSetSuccess() {
       return this.success != null;
     }
 
     public void setSuccessIsSet(boolean value) {
       if (!value) {
         this.success = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException getSec() {
       return this.sec;
     }
 
     public getActiveScans_result setSec(org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
       this.sec = sec;
       return this;
     }
 
     public void unsetSec() {
       this.sec = null;
     }
 
     /** Returns true if field sec is set (has been assigned a value) and false otherwise */
     public boolean isSetSec() {
       return this.sec != null;
     }
 
     public void setSecIsSet(boolean value) {
       if (!value) {
         this.sec = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
           setSuccess((List<ActiveScan>)value);
         }
         break;
 
       case SEC:
         if (value == null) {
           unsetSec();
         } else {
           setSec((org.apache.accumulo.core.security.thrift.ThriftSecurityException)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
         return getSuccess();
 
       case SEC:
         return getSec();
 
       }
       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 SUCCESS:
         return isSetSuccess();
       case SEC:
         return isSetSec();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof getActiveScans_result)
         return this.equals((getActiveScans_result)that);
       return false;
     }
 
     public boolean equals(getActiveScans_result that) {
       if (that == null)
         return false;
 
       boolean this_present_success = true && this.isSetSuccess();
       boolean that_present_success = true && that.isSetSuccess();
       if (this_present_success || that_present_success) {
         if (!(this_present_success && that_present_success))
           return false;
         if (!this.success.equals(that.success))
           return false;
       }
 
       boolean this_present_sec = true && this.isSetSec();
       boolean that_present_sec = true && that.isSetSec();
       if (this_present_sec || that_present_sec) {
         if (!(this_present_sec && that_present_sec))
           return false;
         if (!this.sec.equals(that.sec))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(getActiveScans_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       getActiveScans_result typedOther = (getActiveScans_result)other;
 
       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSuccess()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetSec()).compareTo(typedOther.isSetSec());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSec()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sec, typedOther.sec);
         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("getActiveScans_result(");
       boolean first = true;
 
       sb.append("success:");
       if (this.success == null) {
         sb.append("null");
       } else {
         sb.append(this.success);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("sec:");
       if (this.sec == null) {
         sb.append("null");
       } else {
         sb.append(this.sec);
       }
       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 {
         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 getActiveScans_resultStandardSchemeFactory implements SchemeFactory {
       public getActiveScans_resultStandardScheme getScheme() {
         return new getActiveScans_resultStandardScheme();
       }
     }
 
     private static class getActiveScans_resultStandardScheme extends StandardScheme<getActiveScans_result> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, getActiveScans_result 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 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                 {
                   org.apache.thrift.protocol.TList _list256 = iprot.readListBegin();
                   struct.success = new ArrayList<ActiveScan>(_list256.size);
                   for (int _i257 = 0; _i257 < _list256.size; ++_i257)
                   {
                     ActiveScan _elem258; // required
                     _elem258 = new ActiveScan();
                     _elem258.read(iprot);
                     struct.success.add(_elem258);
                   }
                   iprot.readListEnd();
                 }
                 struct.setSuccessIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // SEC
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
                 struct.sec.read(iprot);
                 struct.setSecIsSet(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, getActiveScans_result struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.success != null) {
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
             for (ActiveScan _iter259 : struct.success)
             {
               _iter259.write(oprot);
             }
             oprot.writeListEnd();
           }
           oprot.writeFieldEnd();
         }
         if (struct.sec != null) {
           oprot.writeFieldBegin(SEC_FIELD_DESC);
           struct.sec.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class getActiveScans_resultTupleSchemeFactory implements SchemeFactory {
       public getActiveScans_resultTupleScheme getScheme() {
         return new getActiveScans_resultTupleScheme();
       }
     }
 
     private static class getActiveScans_resultTupleScheme extends TupleScheme<getActiveScans_result> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, getActiveScans_result struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetSuccess()) {
           optionals.set(0);
         }
         if (struct.isSetSec()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetSuccess()) {
           {
             oprot.writeI32(struct.success.size());
             for (ActiveScan _iter260 : struct.success)
             {
               _iter260.write(oprot);
             }
           }
         }
         if (struct.isSetSec()) {
           struct.sec.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, getActiveScans_result struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           {
             org.apache.thrift.protocol.TList _list261 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
             struct.success = new ArrayList<ActiveScan>(_list261.size);
             for (int _i262 = 0; _i262 < _list261.size; ++_i262)
             {
               ActiveScan _elem263; // required
               _elem263 = new ActiveScan();
               _elem263.read(iprot);
               struct.success.add(_elem263);
             }
           }
           struct.setSuccessIsSet(true);
         }
         if (incoming.get(1)) {
           struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
           struct.sec.read(iprot);
           struct.setSecIsSet(true);
         }
       }
     }
 
   }
 
   public static class getActiveCompactions_args implements org.apache.thrift.TBase<getActiveCompactions_args, getActiveCompactions_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getActiveCompactions_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new getActiveCompactions_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new getActiveCompactions_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)2, "tinfo"),
       CREDENTIAL((short)1, "credential");
 
       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 2: // TINFO
             return TINFO;
           case 1: // CREDENTIAL
             return CREDENTIAL;
           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
     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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getActiveCompactions_args.class, metaDataMap);
     }
 
     public getActiveCompactions_args() {
     }
 
     public getActiveCompactions_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public getActiveCompactions_args(getActiveCompactions_args other) {
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
     }
 
     public getActiveCompactions_args deepCopy() {
       return new getActiveCompactions_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public getActiveCompactions_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public getActiveCompactions_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof getActiveCompactions_args)
         return this.equals((getActiveCompactions_args)that);
       return false;
     }
 
     public boolean equals(getActiveCompactions_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(getActiveCompactions_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       getActiveCompactions_args typedOther = (getActiveCompactions_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         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("getActiveCompactions_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.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, ClassNotFoundException {
       try {
         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 getActiveCompactions_argsStandardSchemeFactory implements SchemeFactory {
       public getActiveCompactions_argsStandardScheme getScheme() {
         return new getActiveCompactions_argsStandardScheme();
       }
     }
 
     private static class getActiveCompactions_argsStandardScheme extends StandardScheme<getActiveCompactions_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, getActiveCompactions_args 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 2: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(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, getActiveCompactions_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class getActiveCompactions_argsTupleSchemeFactory implements SchemeFactory {
       public getActiveCompactions_argsTupleScheme getScheme() {
         return new getActiveCompactions_argsTupleScheme();
       }
     }
 
     private static class getActiveCompactions_argsTupleScheme extends TupleScheme<getActiveCompactions_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, getActiveCompactions_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, getActiveCompactions_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
       }
     }
 
   }
 
   public static class getActiveCompactions_result implements org.apache.thrift.TBase<getActiveCompactions_result, getActiveCompactions_result._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getActiveCompactions_result");
 
     private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
     private static final org.apache.thrift.protocol.TField SEC_FIELD_DESC = new org.apache.thrift.protocol.TField("sec", org.apache.thrift.protocol.TType.STRUCT, (short)1);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new getActiveCompactions_resultStandardSchemeFactory());
       schemes.put(TupleScheme.class, new getActiveCompactions_resultTupleSchemeFactory());
     }
 
     public List<ActiveCompaction> success; // required
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException sec; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       SUCCESS((short)0, "success"),
       SEC((short)1, "sec");
 
       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 0: // SUCCESS
             return SUCCESS;
           case 1: // SEC
             return SEC;
           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
     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.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           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, ActiveCompaction.class))));
       tmpMap.put(_Fields.SEC, new org.apache.thrift.meta_data.FieldMetaData("sec", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getActiveCompactions_result.class, metaDataMap);
     }
 
     public getActiveCompactions_result() {
     }
 
     public getActiveCompactions_result(
       List<ActiveCompaction> success,
       org.apache.accumulo.core.security.thrift.ThriftSecurityException sec)
     {
       this();
       this.success = success;
       this.sec = sec;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public getActiveCompactions_result(getActiveCompactions_result other) {
       if (other.isSetSuccess()) {
         List<ActiveCompaction> __this__success = new ArrayList<ActiveCompaction>();
         for (ActiveCompaction other_element : other.success) {
           __this__success.add(new ActiveCompaction(other_element));
         }
         this.success = __this__success;
       }
       if (other.isSetSec()) {
         this.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException(other.sec);
       }
     }
 
     public getActiveCompactions_result deepCopy() {
       return new getActiveCompactions_result(this);
     }
 
     @Override
     public void clear() {
       this.success = null;
       this.sec = null;
     }
 
     public int getSuccessSize() {
       return (this.success == null) ? 0 : this.success.size();
     }
 
     public java.util.Iterator<ActiveCompaction> getSuccessIterator() {
       return (this.success == null) ? null : this.success.iterator();
     }
 
     public void addToSuccess(ActiveCompaction elem) {
       if (this.success == null) {
         this.success = new ArrayList<ActiveCompaction>();
       }
       this.success.add(elem);
     }
 
     public List<ActiveCompaction> getSuccess() {
       return this.success;
     }
 
     public getActiveCompactions_result setSuccess(List<ActiveCompaction> success) {
       this.success = success;
       return this;
     }
 
     public void unsetSuccess() {
       this.success = null;
     }
 
     /** Returns true if field success is set (has been assigned a value) and false otherwise */
     public boolean isSetSuccess() {
       return this.success != null;
     }
 
     public void setSuccessIsSet(boolean value) {
       if (!value) {
         this.success = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.ThriftSecurityException getSec() {
       return this.sec;
     }
 
     public getActiveCompactions_result setSec(org.apache.accumulo.core.security.thrift.ThriftSecurityException sec) {
       this.sec = sec;
       return this;
     }
 
     public void unsetSec() {
       this.sec = null;
     }
 
     /** Returns true if field sec is set (has been assigned a value) and false otherwise */
     public boolean isSetSec() {
       return this.sec != null;
     }
 
     public void setSecIsSet(boolean value) {
       if (!value) {
         this.sec = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
           setSuccess((List<ActiveCompaction>)value);
         }
         break;
 
       case SEC:
         if (value == null) {
           unsetSec();
         } else {
           setSec((org.apache.accumulo.core.security.thrift.ThriftSecurityException)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
         return getSuccess();
 
       case SEC:
         return getSec();
 
       }
       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 SUCCESS:
         return isSetSuccess();
       case SEC:
         return isSetSec();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof getActiveCompactions_result)
         return this.equals((getActiveCompactions_result)that);
       return false;
     }
 
     public boolean equals(getActiveCompactions_result that) {
       if (that == null)
         return false;
 
       boolean this_present_success = true && this.isSetSuccess();
       boolean that_present_success = true && that.isSetSuccess();
       if (this_present_success || that_present_success) {
         if (!(this_present_success && that_present_success))
           return false;
         if (!this.success.equals(that.success))
           return false;
       }
 
       boolean this_present_sec = true && this.isSetSec();
       boolean that_present_sec = true && that.isSetSec();
       if (this_present_sec || that_present_sec) {
         if (!(this_present_sec && that_present_sec))
           return false;
         if (!this.sec.equals(that.sec))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(getActiveCompactions_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       getActiveCompactions_result typedOther = (getActiveCompactions_result)other;
 
       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSuccess()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetSec()).compareTo(typedOther.isSetSec());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetSec()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sec, typedOther.sec);
         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("getActiveCompactions_result(");
       boolean first = true;
 
       sb.append("success:");
       if (this.success == null) {
         sb.append("null");
       } else {
         sb.append(this.success);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("sec:");
       if (this.sec == null) {
         sb.append("null");
       } else {
         sb.append(this.sec);
       }
       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 {
         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 getActiveCompactions_resultStandardSchemeFactory implements SchemeFactory {
       public getActiveCompactions_resultStandardScheme getScheme() {
         return new getActiveCompactions_resultStandardScheme();
       }
     }
 
     private static class getActiveCompactions_resultStandardScheme extends StandardScheme<getActiveCompactions_result> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, getActiveCompactions_result 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 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                 {
                   org.apache.thrift.protocol.TList _list264 = iprot.readListBegin();
                   struct.success = new ArrayList<ActiveCompaction>(_list264.size);
                   for (int _i265 = 0; _i265 < _list264.size; ++_i265)
                   {
                     ActiveCompaction _elem266; // required
                     _elem266 = new ActiveCompaction();
                     _elem266.read(iprot);
                     struct.success.add(_elem266);
                   }
                   iprot.readListEnd();
                 }
                 struct.setSuccessIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 1: // SEC
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
                 struct.sec.read(iprot);
                 struct.setSecIsSet(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, getActiveCompactions_result struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.success != null) {
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
             for (ActiveCompaction _iter267 : struct.success)
             {
               _iter267.write(oprot);
             }
             oprot.writeListEnd();
           }
           oprot.writeFieldEnd();
         }
         if (struct.sec != null) {
           oprot.writeFieldBegin(SEC_FIELD_DESC);
           struct.sec.write(oprot);
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class getActiveCompactions_resultTupleSchemeFactory implements SchemeFactory {
       public getActiveCompactions_resultTupleScheme getScheme() {
         return new getActiveCompactions_resultTupleScheme();
       }
     }
 
     private static class getActiveCompactions_resultTupleScheme extends TupleScheme<getActiveCompactions_result> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, getActiveCompactions_result struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetSuccess()) {
           optionals.set(0);
         }
         if (struct.isSetSec()) {
           optionals.set(1);
         }
         oprot.writeBitSet(optionals, 2);
         if (struct.isSetSuccess()) {
           {
             oprot.writeI32(struct.success.size());
             for (ActiveCompaction _iter268 : struct.success)
             {
               _iter268.write(oprot);
             }
           }
         }
         if (struct.isSetSec()) {
           struct.sec.write(oprot);
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, getActiveCompactions_result struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(2);
         if (incoming.get(0)) {
           {
             org.apache.thrift.protocol.TList _list269 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
             struct.success = new ArrayList<ActiveCompaction>(_list269.size);
             for (int _i270 = 0; _i270 < _list269.size; ++_i270)
             {
               ActiveCompaction _elem271; // required
               _elem271 = new ActiveCompaction();
               _elem271.read(iprot);
               struct.success.add(_elem271);
             }
           }
           struct.setSuccessIsSet(true);
         }
         if (incoming.get(1)) {
           struct.sec = new org.apache.accumulo.core.security.thrift.ThriftSecurityException();
           struct.sec.read(iprot);
           struct.setSecIsSet(true);
         }
       }
     }
 
   }
 
   public static class removeLogs_args implements org.apache.thrift.TBase<removeLogs_args, removeLogs_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("removeLogs_args");
 
     private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private static final org.apache.thrift.protocol.TField CREDENTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("credential", org.apache.thrift.protocol.TType.STRUCT, (short)2);
     private static final org.apache.thrift.protocol.TField FILENAMES_FIELD_DESC = new org.apache.thrift.protocol.TField("filenames", org.apache.thrift.protocol.TType.LIST, (short)3);
 
     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
     static {
       schemes.put(StandardScheme.class, new removeLogs_argsStandardSchemeFactory());
       schemes.put(TupleScheme.class, new removeLogs_argsTupleSchemeFactory());
     }
 
     public org.apache.accumulo.trace.thrift.TInfo tinfo; // required
     public org.apache.accumulo.core.security.thrift.Credential credential; // required
     public List<String> filenames; // required
 
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
       TINFO((short)1, "tinfo"),
       CREDENTIAL((short)2, "credential"),
       FILENAMES((short)3, "filenames");
 
       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: // TINFO
             return TINFO;
           case 2: // CREDENTIAL
             return CREDENTIAL;
           case 3: // FILENAMES
             return FILENAMES;
           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
     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.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class)));
       tmpMap.put(_Fields.CREDENTIAL, new org.apache.thrift.meta_data.FieldMetaData("credential", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.Credential.class)));
       tmpMap.put(_Fields.FILENAMES, new org.apache.thrift.meta_data.FieldMetaData("filenames", org.apache.thrift.TFieldRequirementType.DEFAULT, 
           new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
               new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(removeLogs_args.class, metaDataMap);
     }
 
     public removeLogs_args() {
     }
 
     public removeLogs_args(
       org.apache.accumulo.trace.thrift.TInfo tinfo,
       org.apache.accumulo.core.security.thrift.Credential credential,
       List<String> filenames)
     {
       this();
       this.tinfo = tinfo;
       this.credential = credential;
       this.filenames = filenames;
     }
 
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public removeLogs_args(removeLogs_args other) {
       if (other.isSetTinfo()) {
         this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo);
       }
       if (other.isSetCredential()) {
         this.credential = new org.apache.accumulo.core.security.thrift.Credential(other.credential);
       }
       if (other.isSetFilenames()) {
         List<String> __this__filenames = new ArrayList<String>();
         for (String other_element : other.filenames) {
           __this__filenames.add(other_element);
         }
         this.filenames = __this__filenames;
       }
     }
 
     public removeLogs_args deepCopy() {
       return new removeLogs_args(this);
     }
 
     @Override
     public void clear() {
       this.tinfo = null;
       this.credential = null;
       this.filenames = null;
     }
 
     public org.apache.accumulo.trace.thrift.TInfo getTinfo() {
       return this.tinfo;
     }
 
     public removeLogs_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) {
       this.tinfo = tinfo;
       return this;
     }
 
     public void unsetTinfo() {
       this.tinfo = null;
     }
 
     /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */
     public boolean isSetTinfo() {
       return this.tinfo != null;
     }
 
     public void setTinfoIsSet(boolean value) {
       if (!value) {
         this.tinfo = null;
       }
     }
 
     public org.apache.accumulo.core.security.thrift.Credential getCredential() {
       return this.credential;
     }
 
     public removeLogs_args setCredential(org.apache.accumulo.core.security.thrift.Credential credential) {
       this.credential = credential;
       return this;
     }
 
     public void unsetCredential() {
       this.credential = null;
     }
 
     /** Returns true if field credential is set (has been assigned a value) and false otherwise */
     public boolean isSetCredential() {
       return this.credential != null;
     }
 
     public void setCredentialIsSet(boolean value) {
       if (!value) {
         this.credential = null;
       }
     }
 
     public int getFilenamesSize() {
       return (this.filenames == null) ? 0 : this.filenames.size();
     }
 
     public java.util.Iterator<String> getFilenamesIterator() {
       return (this.filenames == null) ? null : this.filenames.iterator();
     }
 
     public void addToFilenames(String elem) {
       if (this.filenames == null) {
         this.filenames = new ArrayList<String>();
       }
       this.filenames.add(elem);
     }
 
     public List<String> getFilenames() {
       return this.filenames;
     }
 
     public removeLogs_args setFilenames(List<String> filenames) {
       this.filenames = filenames;
       return this;
     }
 
     public void unsetFilenames() {
       this.filenames = null;
     }
 
     /** Returns true if field filenames is set (has been assigned a value) and false otherwise */
     public boolean isSetFilenames() {
       return this.filenames != null;
     }
 
     public void setFilenamesIsSet(boolean value) {
       if (!value) {
         this.filenames = null;
       }
     }
 
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case TINFO:
         if (value == null) {
           unsetTinfo();
         } else {
           setTinfo((org.apache.accumulo.trace.thrift.TInfo)value);
         }
         break;
 
       case CREDENTIAL:
         if (value == null) {
           unsetCredential();
         } else {
           setCredential((org.apache.accumulo.core.security.thrift.Credential)value);
         }
         break;
 
       case FILENAMES:
         if (value == null) {
           unsetFilenames();
         } else {
           setFilenames((List<String>)value);
         }
         break;
 
       }
     }
 
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case TINFO:
         return getTinfo();
 
       case CREDENTIAL:
         return getCredential();
 
       case FILENAMES:
         return getFilenames();
 
       }
       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 TINFO:
         return isSetTinfo();
       case CREDENTIAL:
         return isSetCredential();
       case FILENAMES:
         return isSetFilenames();
       }
       throw new IllegalStateException();
     }
 
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
       if (that instanceof removeLogs_args)
         return this.equals((removeLogs_args)that);
       return false;
     }
 
     public boolean equals(removeLogs_args that) {
       if (that == null)
         return false;
 
       boolean this_present_tinfo = true && this.isSetTinfo();
       boolean that_present_tinfo = true && that.isSetTinfo();
       if (this_present_tinfo || that_present_tinfo) {
         if (!(this_present_tinfo && that_present_tinfo))
           return false;
         if (!this.tinfo.equals(that.tinfo))
           return false;
       }
 
       boolean this_present_credential = true && this.isSetCredential();
       boolean that_present_credential = true && that.isSetCredential();
       if (this_present_credential || that_present_credential) {
         if (!(this_present_credential && that_present_credential))
           return false;
         if (!this.credential.equals(that.credential))
           return false;
       }
 
       boolean this_present_filenames = true && this.isSetFilenames();
       boolean that_present_filenames = true && that.isSetFilenames();
       if (this_present_filenames || that_present_filenames) {
         if (!(this_present_filenames && that_present_filenames))
           return false;
         if (!this.filenames.equals(that.filenames))
           return false;
       }
 
       return true;
     }
 
     @Override
     public int hashCode() {
       return 0;
     }
 
     public int compareTo(removeLogs_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
       }
 
       int lastComparison = 0;
       removeLogs_args typedOther = (removeLogs_args)other;
 
       lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetTinfo()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetCredential()).compareTo(typedOther.isSetCredential());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetCredential()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credential, typedOther.credential);
         if (lastComparison != 0) {
           return lastComparison;
         }
       }
       lastComparison = Boolean.valueOf(isSetFilenames()).compareTo(typedOther.isSetFilenames());
       if (lastComparison != 0) {
         return lastComparison;
       }
       if (isSetFilenames()) {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.filenames, typedOther.filenames);
         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("removeLogs_args(");
       boolean first = true;
 
       sb.append("tinfo:");
       if (this.tinfo == null) {
         sb.append("null");
       } else {
         sb.append(this.tinfo);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("credential:");
       if (this.credential == null) {
         sb.append("null");
       } else {
         sb.append(this.credential);
       }
       first = false;
       if (!first) sb.append(", ");
       sb.append("filenames:");
       if (this.filenames == null) {
         sb.append("null");
       } else {
         sb.append(this.filenames);
       }
       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 (tinfo != null) {
         tinfo.validate();
       }
       if (credential != null) {
         credential.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, ClassNotFoundException {
       try {
         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 removeLogs_argsStandardSchemeFactory implements SchemeFactory {
       public removeLogs_argsStandardScheme getScheme() {
         return new removeLogs_argsStandardScheme();
       }
     }
 
     private static class removeLogs_argsStandardScheme extends StandardScheme<removeLogs_args> {
 
       public void read(org.apache.thrift.protocol.TProtocol iprot, removeLogs_args 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: // TINFO
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
                 struct.tinfo.read(iprot);
                 struct.setTinfoIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 2: // CREDENTIAL
               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                 struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
                 struct.credential.read(iprot);
                 struct.setCredentialIsSet(true);
               } else { 
                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
               }
               break;
             case 3: // FILENAMES
               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                 {
                   org.apache.thrift.protocol.TList _list272 = iprot.readListBegin();
                   struct.filenames = new ArrayList<String>(_list272.size);
                   for (int _i273 = 0; _i273 < _list272.size; ++_i273)
                   {
                     String _elem274; // required
                     _elem274 = iprot.readString();
                     struct.filenames.add(_elem274);
                   }
                   iprot.readListEnd();
                 }
                 struct.setFilenamesIsSet(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, removeLogs_args struct) throws org.apache.thrift.TException {
         struct.validate();
 
         oprot.writeStructBegin(STRUCT_DESC);
         if (struct.tinfo != null) {
           oprot.writeFieldBegin(TINFO_FIELD_DESC);
           struct.tinfo.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.credential != null) {
           oprot.writeFieldBegin(CREDENTIAL_FIELD_DESC);
           struct.credential.write(oprot);
           oprot.writeFieldEnd();
         }
         if (struct.filenames != null) {
           oprot.writeFieldBegin(FILENAMES_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.filenames.size()));
             for (String _iter275 : struct.filenames)
             {
               oprot.writeString(_iter275);
             }
             oprot.writeListEnd();
           }
           oprot.writeFieldEnd();
         }
         oprot.writeFieldStop();
         oprot.writeStructEnd();
       }
 
     }
 
     private static class removeLogs_argsTupleSchemeFactory implements SchemeFactory {
       public removeLogs_argsTupleScheme getScheme() {
         return new removeLogs_argsTupleScheme();
       }
     }
 
     private static class removeLogs_argsTupleScheme extends TupleScheme<removeLogs_args> {
 
       @Override
       public void write(org.apache.thrift.protocol.TProtocol prot, removeLogs_args struct) throws org.apache.thrift.TException {
         TTupleProtocol oprot = (TTupleProtocol) prot;
         BitSet optionals = new BitSet();
         if (struct.isSetTinfo()) {
           optionals.set(0);
         }
         if (struct.isSetCredential()) {
           optionals.set(1);
         }
         if (struct.isSetFilenames()) {
           optionals.set(2);
         }
         oprot.writeBitSet(optionals, 3);
         if (struct.isSetTinfo()) {
           struct.tinfo.write(oprot);
         }
         if (struct.isSetCredential()) {
           struct.credential.write(oprot);
         }
         if (struct.isSetFilenames()) {
           {
             oprot.writeI32(struct.filenames.size());
             for (String _iter276 : struct.filenames)
             {
               oprot.writeString(_iter276);
             }
           }
         }
       }
 
       @Override
       public void read(org.apache.thrift.protocol.TProtocol prot, removeLogs_args struct) throws org.apache.thrift.TException {
         TTupleProtocol iprot = (TTupleProtocol) prot;
         BitSet incoming = iprot.readBitSet(3);
         if (incoming.get(0)) {
           struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo();
           struct.tinfo.read(iprot);
           struct.setTinfoIsSet(true);
         }
         if (incoming.get(1)) {
           struct.credential = new org.apache.accumulo.core.security.thrift.Credential();
           struct.credential.read(iprot);
           struct.setCredentialIsSet(true);
         }
         if (incoming.get(2)) {
           {
             org.apache.thrift.protocol.TList _list277 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
             struct.filenames = new ArrayList<String>(_list277.size);
             for (int _i278 = 0; _i278 < _list277.size; ++_i278)
             {
               String _elem279; // required
               _elem279 = iprot.readString();
               struct.filenames.add(_elem279);
             }
           }
           struct.setFilenamesIsSet(true);
         }
       }
     }
 
   }
 
 }