accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ktur...@apache.org
Subject [3/4] ACCUMULO-1611 added conditional mutations to proxy
Date Wed, 11 Sep 2013 19:15:43 GMT
http://git-wip-us.apache.org/repos/asf/accumulo/blob/176df80f/proxy/src/main/java/org/apache/accumulo/proxy/thrift/AccumuloProxy.java
----------------------------------------------------------------------
diff --git a/proxy/src/main/java/org/apache/accumulo/proxy/thrift/AccumuloProxy.java b/proxy/src/main/java/org/apache/accumulo/proxy/thrift/AccumuloProxy.java
index 7476a42..ca9c415 100644
--- a/proxy/src/main/java/org/apache/accumulo/proxy/thrift/AccumuloProxy.java
+++ b/proxy/src/main/java/org/apache/accumulo/proxy/thrift/AccumuloProxy.java
@@ -192,6 +192,14 @@ import org.slf4j.LoggerFactory;
 
     public void closeWriter(String writer) throws UnknownWriter, MutationsRejectedException, org.apache.thrift.TException;
 
+    public ConditionalStatus updateRowConditionally(ByteBuffer login, String tableName, ByteBuffer row, ConditionalUpdates updates) throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException;
+
+    public String createConditionalWriter(ByteBuffer login, String tableName, ConditionalWriterOptions options) throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException;
+
+    public Map<ByteBuffer,ConditionalStatus> updateRowsConditionally(String conditionalWriter, Map<ByteBuffer,ConditionalUpdates> updates) throws UnknownWriter, AccumuloException, AccumuloSecurityException, org.apache.thrift.TException;
+
+    public void closeConditionalWriter(String conditionalWriter) throws org.apache.thrift.TException;
+
     public Range getRowRange(ByteBuffer row) throws org.apache.thrift.TException;
 
     public Key getFollowing(Key key, PartialKey part) throws org.apache.thrift.TException;
@@ -342,6 +350,14 @@ import org.slf4j.LoggerFactory;
 
     public void closeWriter(String writer, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.closeWriter_call> resultHandler) throws org.apache.thrift.TException;
 
+    public void updateRowConditionally(ByteBuffer login, String tableName, ByteBuffer row, ConditionalUpdates updates, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.updateRowConditionally_call> resultHandler) throws org.apache.thrift.TException;
+
+    public void createConditionalWriter(ByteBuffer login, String tableName, ConditionalWriterOptions options, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.createConditionalWriter_call> resultHandler) throws org.apache.thrift.TException;
+
+    public void updateRowsConditionally(String conditionalWriter, Map<ByteBuffer,ConditionalUpdates> updates, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.updateRowsConditionally_call> resultHandler) throws org.apache.thrift.TException;
+
+    public void closeConditionalWriter(String conditionalWriter, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.closeConditionalWriter_call> resultHandler) throws org.apache.thrift.TException;
+
     public void getRowRange(ByteBuffer row, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getRowRange_call> resultHandler) throws org.apache.thrift.TException;
 
     public void getFollowing(Key key, PartialKey part, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getFollowing_call> resultHandler) throws org.apache.thrift.TException;
@@ -2526,6 +2542,128 @@ import org.slf4j.LoggerFactory;
       return;
     }
 
+    public ConditionalStatus updateRowConditionally(ByteBuffer login, String tableName, ByteBuffer row, ConditionalUpdates updates) throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException
+    {
+      send_updateRowConditionally(login, tableName, row, updates);
+      return recv_updateRowConditionally();
+    }
+
+    public void send_updateRowConditionally(ByteBuffer login, String tableName, ByteBuffer row, ConditionalUpdates updates) throws org.apache.thrift.TException
+    {
+      updateRowConditionally_args args = new updateRowConditionally_args();
+      args.setLogin(login);
+      args.setTableName(tableName);
+      args.setRow(row);
+      args.setUpdates(updates);
+      sendBase("updateRowConditionally", args);
+    }
+
+    public ConditionalStatus recv_updateRowConditionally() throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException
+    {
+      updateRowConditionally_result result = new updateRowConditionally_result();
+      receiveBase(result, "updateRowConditionally");
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.ouch1 != null) {
+        throw result.ouch1;
+      }
+      if (result.ouch2 != null) {
+        throw result.ouch2;
+      }
+      if (result.ouch3 != null) {
+        throw result.ouch3;
+      }
+      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "updateRowConditionally failed: unknown result");
+    }
+
+    public String createConditionalWriter(ByteBuffer login, String tableName, ConditionalWriterOptions options) throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException
+    {
+      send_createConditionalWriter(login, tableName, options);
+      return recv_createConditionalWriter();
+    }
+
+    public void send_createConditionalWriter(ByteBuffer login, String tableName, ConditionalWriterOptions options) throws org.apache.thrift.TException
+    {
+      createConditionalWriter_args args = new createConditionalWriter_args();
+      args.setLogin(login);
+      args.setTableName(tableName);
+      args.setOptions(options);
+      sendBase("createConditionalWriter", args);
+    }
+
+    public String recv_createConditionalWriter() throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException
+    {
+      createConditionalWriter_result result = new createConditionalWriter_result();
+      receiveBase(result, "createConditionalWriter");
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.ouch1 != null) {
+        throw result.ouch1;
+      }
+      if (result.ouch2 != null) {
+        throw result.ouch2;
+      }
+      if (result.ouch3 != null) {
+        throw result.ouch3;
+      }
+      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "createConditionalWriter failed: unknown result");
+    }
+
+    public Map<ByteBuffer,ConditionalStatus> updateRowsConditionally(String conditionalWriter, Map<ByteBuffer,ConditionalUpdates> updates) throws UnknownWriter, AccumuloException, AccumuloSecurityException, org.apache.thrift.TException
+    {
+      send_updateRowsConditionally(conditionalWriter, updates);
+      return recv_updateRowsConditionally();
+    }
+
+    public void send_updateRowsConditionally(String conditionalWriter, Map<ByteBuffer,ConditionalUpdates> updates) throws org.apache.thrift.TException
+    {
+      updateRowsConditionally_args args = new updateRowsConditionally_args();
+      args.setConditionalWriter(conditionalWriter);
+      args.setUpdates(updates);
+      sendBase("updateRowsConditionally", args);
+    }
+
+    public Map<ByteBuffer,ConditionalStatus> recv_updateRowsConditionally() throws UnknownWriter, AccumuloException, AccumuloSecurityException, org.apache.thrift.TException
+    {
+      updateRowsConditionally_result result = new updateRowsConditionally_result();
+      receiveBase(result, "updateRowsConditionally");
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.ouch1 != null) {
+        throw result.ouch1;
+      }
+      if (result.ouch2 != null) {
+        throw result.ouch2;
+      }
+      if (result.ouch3 != null) {
+        throw result.ouch3;
+      }
+      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "updateRowsConditionally failed: unknown result");
+    }
+
+    public void closeConditionalWriter(String conditionalWriter) throws org.apache.thrift.TException
+    {
+      send_closeConditionalWriter(conditionalWriter);
+      recv_closeConditionalWriter();
+    }
+
+    public void send_closeConditionalWriter(String conditionalWriter) throws org.apache.thrift.TException
+    {
+      closeConditionalWriter_args args = new closeConditionalWriter_args();
+      args.setConditionalWriter(conditionalWriter);
+      sendBase("closeConditionalWriter", args);
+    }
+
+    public void recv_closeConditionalWriter() throws org.apache.thrift.TException
+    {
+      closeConditionalWriter_result result = new closeConditionalWriter_result();
+      receiveBase(result, "closeConditionalWriter");
+      return;
+    }
+
     public Range getRowRange(ByteBuffer row) throws org.apache.thrift.TException
     {
       send_getRowRange(row);
@@ -5246,6 +5384,152 @@ import org.slf4j.LoggerFactory;
       }
     }
 
+    public void updateRowConditionally(ByteBuffer login, String tableName, ByteBuffer row, ConditionalUpdates updates, org.apache.thrift.async.AsyncMethodCallback<updateRowConditionally_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      updateRowConditionally_call method_call = new updateRowConditionally_call(login, tableName, row, updates, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+
+    public static class updateRowConditionally_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private ByteBuffer login;
+      private String tableName;
+      private ByteBuffer row;
+      private ConditionalUpdates updates;
+      public updateRowConditionally_call(ByteBuffer login, String tableName, ByteBuffer row, ConditionalUpdates updates, org.apache.thrift.async.AsyncMethodCallback<updateRowConditionally_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.login = login;
+        this.tableName = tableName;
+        this.row = row;
+        this.updates = updates;
+      }
+
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("updateRowConditionally", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        updateRowConditionally_args args = new updateRowConditionally_args();
+        args.setLogin(login);
+        args.setTableName(tableName);
+        args.setRow(row);
+        args.setUpdates(updates);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+
+      public ConditionalStatus getResult() throws AccumuloException, AccumuloSecurityException, TableNotFoundException, 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_updateRowConditionally();
+      }
+    }
+
+    public void createConditionalWriter(ByteBuffer login, String tableName, ConditionalWriterOptions options, org.apache.thrift.async.AsyncMethodCallback<createConditionalWriter_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      createConditionalWriter_call method_call = new createConditionalWriter_call(login, tableName, options, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+
+    public static class createConditionalWriter_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private ByteBuffer login;
+      private String tableName;
+      private ConditionalWriterOptions options;
+      public createConditionalWriter_call(ByteBuffer login, String tableName, ConditionalWriterOptions options, org.apache.thrift.async.AsyncMethodCallback<createConditionalWriter_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.login = login;
+        this.tableName = tableName;
+        this.options = options;
+      }
+
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("createConditionalWriter", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        createConditionalWriter_args args = new createConditionalWriter_args();
+        args.setLogin(login);
+        args.setTableName(tableName);
+        args.setOptions(options);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+
+      public String getResult() throws AccumuloException, AccumuloSecurityException, TableNotFoundException, 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_createConditionalWriter();
+      }
+    }
+
+    public void updateRowsConditionally(String conditionalWriter, Map<ByteBuffer,ConditionalUpdates> updates, org.apache.thrift.async.AsyncMethodCallback<updateRowsConditionally_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      updateRowsConditionally_call method_call = new updateRowsConditionally_call(conditionalWriter, updates, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+
+    public static class updateRowsConditionally_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private String conditionalWriter;
+      private Map<ByteBuffer,ConditionalUpdates> updates;
+      public updateRowsConditionally_call(String conditionalWriter, Map<ByteBuffer,ConditionalUpdates> updates, org.apache.thrift.async.AsyncMethodCallback<updateRowsConditionally_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.conditionalWriter = conditionalWriter;
+        this.updates = updates;
+      }
+
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("updateRowsConditionally", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        updateRowsConditionally_args args = new updateRowsConditionally_args();
+        args.setConditionalWriter(conditionalWriter);
+        args.setUpdates(updates);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+
+      public Map<ByteBuffer,ConditionalStatus> getResult() throws UnknownWriter, AccumuloException, AccumuloSecurityException, 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_updateRowsConditionally();
+      }
+    }
+
+    public void closeConditionalWriter(String conditionalWriter, org.apache.thrift.async.AsyncMethodCallback<closeConditionalWriter_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      closeConditionalWriter_call method_call = new closeConditionalWriter_call(conditionalWriter, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+
+    public static class closeConditionalWriter_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private String conditionalWriter;
+      public closeConditionalWriter_call(String conditionalWriter, org.apache.thrift.async.AsyncMethodCallback<closeConditionalWriter_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.conditionalWriter = conditionalWriter;
+      }
+
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("closeConditionalWriter", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        closeConditionalWriter_args args = new closeConditionalWriter_args();
+        args.setConditionalWriter(conditionalWriter);
+        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);
+        (new Client(prot)).recv_closeConditionalWriter();
+      }
+    }
+
     public void getRowRange(ByteBuffer row, org.apache.thrift.async.AsyncMethodCallback<getRowRange_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       getRowRange_call method_call = new getRowRange_call(row, resultHandler, this, ___protocolFactory, ___transport);
@@ -5397,6 +5681,10 @@ import org.slf4j.LoggerFactory;
       processMap.put("update", new update());
       processMap.put("flush", new flush());
       processMap.put("closeWriter", new closeWriter());
+      processMap.put("updateRowConditionally", new updateRowConditionally());
+      processMap.put("createConditionalWriter", new createConditionalWriter());
+      processMap.put("updateRowsConditionally", new updateRowsConditionally());
+      processMap.put("closeConditionalWriter", new closeConditionalWriter());
       processMap.put("getRowRange", new getRowRange());
       processMap.put("getFollowing", new getFollowing());
       return processMap;
@@ -7309,6 +7597,110 @@ import org.slf4j.LoggerFactory;
       }
     }
 
+    public static class updateRowConditionally<I extends Iface> extends org.apache.thrift.ProcessFunction<I, updateRowConditionally_args> {
+      public updateRowConditionally() {
+        super("updateRowConditionally");
+      }
+
+      public updateRowConditionally_args getEmptyArgsInstance() {
+        return new updateRowConditionally_args();
+      }
+
+      protected boolean isOneway() {
+        return false;
+      }
+
+      public updateRowConditionally_result getResult(I iface, updateRowConditionally_args args) throws org.apache.thrift.TException {
+        updateRowConditionally_result result = new updateRowConditionally_result();
+        try {
+          result.success = iface.updateRowConditionally(args.login, args.tableName, args.row, args.updates);
+        } catch (AccumuloException ouch1) {
+          result.ouch1 = ouch1;
+        } catch (AccumuloSecurityException ouch2) {
+          result.ouch2 = ouch2;
+        } catch (TableNotFoundException ouch3) {
+          result.ouch3 = ouch3;
+        }
+        return result;
+      }
+    }
+
+    public static class createConditionalWriter<I extends Iface> extends org.apache.thrift.ProcessFunction<I, createConditionalWriter_args> {
+      public createConditionalWriter() {
+        super("createConditionalWriter");
+      }
+
+      public createConditionalWriter_args getEmptyArgsInstance() {
+        return new createConditionalWriter_args();
+      }
+
+      protected boolean isOneway() {
+        return false;
+      }
+
+      public createConditionalWriter_result getResult(I iface, createConditionalWriter_args args) throws org.apache.thrift.TException {
+        createConditionalWriter_result result = new createConditionalWriter_result();
+        try {
+          result.success = iface.createConditionalWriter(args.login, args.tableName, args.options);
+        } catch (AccumuloException ouch1) {
+          result.ouch1 = ouch1;
+        } catch (AccumuloSecurityException ouch2) {
+          result.ouch2 = ouch2;
+        } catch (TableNotFoundException ouch3) {
+          result.ouch3 = ouch3;
+        }
+        return result;
+      }
+    }
+
+    public static class updateRowsConditionally<I extends Iface> extends org.apache.thrift.ProcessFunction<I, updateRowsConditionally_args> {
+      public updateRowsConditionally() {
+        super("updateRowsConditionally");
+      }
+
+      public updateRowsConditionally_args getEmptyArgsInstance() {
+        return new updateRowsConditionally_args();
+      }
+
+      protected boolean isOneway() {
+        return false;
+      }
+
+      public updateRowsConditionally_result getResult(I iface, updateRowsConditionally_args args) throws org.apache.thrift.TException {
+        updateRowsConditionally_result result = new updateRowsConditionally_result();
+        try {
+          result.success = iface.updateRowsConditionally(args.conditionalWriter, args.updates);
+        } catch (UnknownWriter ouch1) {
+          result.ouch1 = ouch1;
+        } catch (AccumuloException ouch2) {
+          result.ouch2 = ouch2;
+        } catch (AccumuloSecurityException ouch3) {
+          result.ouch3 = ouch3;
+        }
+        return result;
+      }
+    }
+
+    public static class closeConditionalWriter<I extends Iface> extends org.apache.thrift.ProcessFunction<I, closeConditionalWriter_args> {
+      public closeConditionalWriter() {
+        super("closeConditionalWriter");
+      }
+
+      public closeConditionalWriter_args getEmptyArgsInstance() {
+        return new closeConditionalWriter_args();
+      }
+
+      protected boolean isOneway() {
+        return false;
+      }
+
+      public closeConditionalWriter_result getResult(I iface, closeConditionalWriter_args args) throws org.apache.thrift.TException {
+        closeConditionalWriter_result result = new closeConditionalWriter_result();
+        iface.closeConditionalWriter(args.conditionalWriter);
+        return result;
+      }
+    }
+
     public static class getRowRange<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getRowRange_args> {
       public getRowRange() {
         super("getRowRange");
@@ -7750,15 +8142,15 @@ import org.slf4j.LoggerFactory;
             case 2: // LOGIN_PROPERTIES
               if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
                 {
-                  org.apache.thrift.protocol.TMap _map122 = iprot.readMapBegin();
-                  struct.loginProperties = new HashMap<String,String>(2*_map122.size);
-                  for (int _i123 = 0; _i123 < _map122.size; ++_i123)
+                  org.apache.thrift.protocol.TMap _map154 = iprot.readMapBegin();
+                  struct.loginProperties = new HashMap<String,String>(2*_map154.size);
+                  for (int _i155 = 0; _i155 < _map154.size; ++_i155)
                   {
-                    String _key124; // required
-                    String _val125; // required
-                    _key124 = iprot.readString();
-                    _val125 = iprot.readString();
-                    struct.loginProperties.put(_key124, _val125);
+                    String _key156; // required
+                    String _val157; // required
+                    _key156 = iprot.readString();
+                    _val157 = iprot.readString();
+                    struct.loginProperties.put(_key156, _val157);
                   }
                   iprot.readMapEnd();
                 }
@@ -7791,10 +8183,10 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(LOGIN_PROPERTIES_FIELD_DESC);
           {
             oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.loginProperties.size()));
-            for (Map.Entry<String, String> _iter126 : struct.loginProperties.entrySet())
+            for (Map.Entry<String, String> _iter158 : struct.loginProperties.entrySet())
             {
-              oprot.writeString(_iter126.getKey());
-              oprot.writeString(_iter126.getValue());
+              oprot.writeString(_iter158.getKey());
+              oprot.writeString(_iter158.getValue());
             }
             oprot.writeMapEnd();
           }
@@ -7831,10 +8223,10 @@ import org.slf4j.LoggerFactory;
         if (struct.isSetLoginProperties()) {
           {
             oprot.writeI32(struct.loginProperties.size());
-            for (Map.Entry<String, String> _iter127 : struct.loginProperties.entrySet())
+            for (Map.Entry<String, String> _iter159 : struct.loginProperties.entrySet())
             {
-              oprot.writeString(_iter127.getKey());
-              oprot.writeString(_iter127.getValue());
+              oprot.writeString(_iter159.getKey());
+              oprot.writeString(_iter159.getValue());
             }
           }
         }
@@ -7850,15 +8242,15 @@ import org.slf4j.LoggerFactory;
         }
         if (incoming.get(1)) {
           {
-            org.apache.thrift.protocol.TMap _map128 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32());
-            struct.loginProperties = new HashMap<String,String>(2*_map128.size);
-            for (int _i129 = 0; _i129 < _map128.size; ++_i129)
+            org.apache.thrift.protocol.TMap _map160 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32());
+            struct.loginProperties = new HashMap<String,String>(2*_map160.size);
+            for (int _i161 = 0; _i161 < _map160.size; ++_i161)
             {
-              String _key130; // required
-              String _val131; // required
-              _key130 = iprot.readString();
-              _val131 = iprot.readString();
-              struct.loginProperties.put(_key130, _val131);
+              String _key162; // required
+              String _val163; // required
+              _key162 = iprot.readString();
+              _val163 = iprot.readString();
+              struct.loginProperties.put(_key162, _val163);
             }
           }
           struct.setLoginPropertiesIsSet(true);
@@ -10052,13 +10444,13 @@ import org.slf4j.LoggerFactory;
             case 3: // SPLITS
               if (schemeField.type == org.apache.thrift.protocol.TType.SET) {
                 {
-                  org.apache.thrift.protocol.TSet _set132 = iprot.readSetBegin();
-                  struct.splits = new HashSet<ByteBuffer>(2*_set132.size);
-                  for (int _i133 = 0; _i133 < _set132.size; ++_i133)
+                  org.apache.thrift.protocol.TSet _set164 = iprot.readSetBegin();
+                  struct.splits = new HashSet<ByteBuffer>(2*_set164.size);
+                  for (int _i165 = 0; _i165 < _set164.size; ++_i165)
                   {
-                    ByteBuffer _elem134; // optional
-                    _elem134 = iprot.readBinary();
-                    struct.splits.add(_elem134);
+                    ByteBuffer _elem166; // required
+                    _elem166 = iprot.readBinary();
+                    struct.splits.add(_elem166);
                   }
                   iprot.readSetEnd();
                 }
@@ -10096,9 +10488,9 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(SPLITS_FIELD_DESC);
           {
             oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, struct.splits.size()));
-            for (ByteBuffer _iter135 : struct.splits)
+            for (ByteBuffer _iter167 : struct.splits)
             {
-              oprot.writeBinary(_iter135);
+              oprot.writeBinary(_iter167);
             }
             oprot.writeSetEnd();
           }
@@ -10141,9 +10533,9 @@ import org.slf4j.LoggerFactory;
         if (struct.isSetSplits()) {
           {
             oprot.writeI32(struct.splits.size());
-            for (ByteBuffer _iter136 : struct.splits)
+            for (ByteBuffer _iter168 : struct.splits)
             {
-              oprot.writeBinary(_iter136);
+              oprot.writeBinary(_iter168);
             }
           }
         }
@@ -10163,13 +10555,13 @@ import org.slf4j.LoggerFactory;
         }
         if (incoming.get(2)) {
           {
-            org.apache.thrift.protocol.TSet _set137 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
-            struct.splits = new HashSet<ByteBuffer>(2*_set137.size);
-            for (int _i138 = 0; _i138 < _set137.size; ++_i138)
+            org.apache.thrift.protocol.TSet _set169 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
+            struct.splits = new HashSet<ByteBuffer>(2*_set169.size);
+            for (int _i170 = 0; _i170 < _set169.size; ++_i170)
             {
-              ByteBuffer _elem139; // optional
-              _elem139 = iprot.readBinary();
-              struct.splits.add(_elem139);
+              ByteBuffer _elem171; // required
+              _elem171 = iprot.readBinary();
+              struct.splits.add(_elem171);
             }
           }
           struct.setSplitsIsSet(true);
@@ -11318,13 +11710,13 @@ import org.slf4j.LoggerFactory;
             case 4: // SCOPES
               if (schemeField.type == org.apache.thrift.protocol.TType.SET) {
                 {
-                  org.apache.thrift.protocol.TSet _set140 = iprot.readSetBegin();
-                  struct.scopes = new HashSet<IteratorScope>(2*_set140.size);
-                  for (int _i141 = 0; _i141 < _set140.size; ++_i141)
+                  org.apache.thrift.protocol.TSet _set172 = iprot.readSetBegin();
+                  struct.scopes = new HashSet<IteratorScope>(2*_set172.size);
+                  for (int _i173 = 0; _i173 < _set172.size; ++_i173)
                   {
-                    IteratorScope _elem142; // optional
-                    _elem142 = IteratorScope.findByValue(iprot.readI32());
-                    struct.scopes.add(_elem142);
+                    IteratorScope _elem174; // required
+                    _elem174 = IteratorScope.findByValue(iprot.readI32());
+                    struct.scopes.add(_elem174);
                   }
                   iprot.readSetEnd();
                 }
@@ -11367,9 +11759,9 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(SCOPES_FIELD_DESC);
           {
             oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, struct.scopes.size()));
-            for (IteratorScope _iter143 : struct.scopes)
+            for (IteratorScope _iter175 : struct.scopes)
             {
-              oprot.writeI32(_iter143.getValue());
+              oprot.writeI32(_iter175.getValue());
             }
             oprot.writeSetEnd();
           }
@@ -11418,9 +11810,9 @@ import org.slf4j.LoggerFactory;
         if (struct.isSetScopes()) {
           {
             oprot.writeI32(struct.scopes.size());
-            for (IteratorScope _iter144 : struct.scopes)
+            for (IteratorScope _iter176 : struct.scopes)
             {
-              oprot.writeI32(_iter144.getValue());
+              oprot.writeI32(_iter176.getValue());
             }
           }
         }
@@ -11445,13 +11837,13 @@ import org.slf4j.LoggerFactory;
         }
         if (incoming.get(3)) {
           {
-            org.apache.thrift.protocol.TSet _set145 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, iprot.readI32());
-            struct.scopes = new HashSet<IteratorScope>(2*_set145.size);
-            for (int _i146 = 0; _i146 < _set145.size; ++_i146)
+            org.apache.thrift.protocol.TSet _set177 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, iprot.readI32());
+            struct.scopes = new HashSet<IteratorScope>(2*_set177.size);
+            for (int _i178 = 0; _i178 < _set177.size; ++_i178)
             {
-              IteratorScope _elem147; // optional
-              _elem147 = IteratorScope.findByValue(iprot.readI32());
-              struct.scopes.add(_elem147);
+              IteratorScope _elem179; // required
+              _elem179 = IteratorScope.findByValue(iprot.readI32());
+              struct.scopes.add(_elem179);
             }
           }
           struct.setScopesIsSet(true);
@@ -12600,13 +12992,13 @@ import org.slf4j.LoggerFactory;
             case 4: // SCOPES
               if (schemeField.type == org.apache.thrift.protocol.TType.SET) {
                 {
-                  org.apache.thrift.protocol.TSet _set148 = iprot.readSetBegin();
-                  struct.scopes = new HashSet<IteratorScope>(2*_set148.size);
-                  for (int _i149 = 0; _i149 < _set148.size; ++_i149)
+                  org.apache.thrift.protocol.TSet _set180 = iprot.readSetBegin();
+                  struct.scopes = new HashSet<IteratorScope>(2*_set180.size);
+                  for (int _i181 = 0; _i181 < _set180.size; ++_i181)
                   {
-                    IteratorScope _elem150; // optional
-                    _elem150 = IteratorScope.findByValue(iprot.readI32());
-                    struct.scopes.add(_elem150);
+                    IteratorScope _elem182; // required
+                    _elem182 = IteratorScope.findByValue(iprot.readI32());
+                    struct.scopes.add(_elem182);
                   }
                   iprot.readSetEnd();
                 }
@@ -12649,9 +13041,9 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(SCOPES_FIELD_DESC);
           {
             oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, struct.scopes.size()));
-            for (IteratorScope _iter151 : struct.scopes)
+            for (IteratorScope _iter183 : struct.scopes)
             {
-              oprot.writeI32(_iter151.getValue());
+              oprot.writeI32(_iter183.getValue());
             }
             oprot.writeSetEnd();
           }
@@ -12700,9 +13092,9 @@ import org.slf4j.LoggerFactory;
         if (struct.isSetScopes()) {
           {
             oprot.writeI32(struct.scopes.size());
-            for (IteratorScope _iter152 : struct.scopes)
+            for (IteratorScope _iter184 : struct.scopes)
             {
-              oprot.writeI32(_iter152.getValue());
+              oprot.writeI32(_iter184.getValue());
             }
           }
         }
@@ -12727,13 +13119,13 @@ import org.slf4j.LoggerFactory;
         }
         if (incoming.get(3)) {
           {
-            org.apache.thrift.protocol.TSet _set153 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, iprot.readI32());
-            struct.scopes = new HashSet<IteratorScope>(2*_set153.size);
-            for (int _i154 = 0; _i154 < _set153.size; ++_i154)
+            org.apache.thrift.protocol.TSet _set185 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, iprot.readI32());
+            struct.scopes = new HashSet<IteratorScope>(2*_set185.size);
+            for (int _i186 = 0; _i186 < _set185.size; ++_i186)
             {
-              IteratorScope _elem155; // optional
-              _elem155 = IteratorScope.findByValue(iprot.readI32());
-              struct.scopes.add(_elem155);
+              IteratorScope _elem187; // required
+              _elem187 = IteratorScope.findByValue(iprot.readI32());
+              struct.scopes.add(_elem187);
             }
           }
           struct.setScopesIsSet(true);
@@ -14886,15 +15278,15 @@ import org.slf4j.LoggerFactory;
             case 5: // PROPERTIES_TO_SET
               if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
                 {
-                  org.apache.thrift.protocol.TMap _map156 = iprot.readMapBegin();
-                  struct.propertiesToSet = new HashMap<String,String>(2*_map156.size);
-                  for (int _i157 = 0; _i157 < _map156.size; ++_i157)
+                  org.apache.thrift.protocol.TMap _map188 = iprot.readMapBegin();
+                  struct.propertiesToSet = new HashMap<String,String>(2*_map188.size);
+                  for (int _i189 = 0; _i189 < _map188.size; ++_i189)
                   {
-                    String _key158; // required
-                    String _val159; // required
-                    _key158 = iprot.readString();
-                    _val159 = iprot.readString();
-                    struct.propertiesToSet.put(_key158, _val159);
+                    String _key190; // required
+                    String _val191; // required
+                    _key190 = iprot.readString();
+                    _val191 = iprot.readString();
+                    struct.propertiesToSet.put(_key190, _val191);
                   }
                   iprot.readMapEnd();
                 }
@@ -14906,13 +15298,13 @@ import org.slf4j.LoggerFactory;
             case 6: // PROPERTIES_TO_EXCLUDE
               if (schemeField.type == org.apache.thrift.protocol.TType.SET) {
                 {
-                  org.apache.thrift.protocol.TSet _set160 = iprot.readSetBegin();
-                  struct.propertiesToExclude = new HashSet<String>(2*_set160.size);
-                  for (int _i161 = 0; _i161 < _set160.size; ++_i161)
+                  org.apache.thrift.protocol.TSet _set192 = iprot.readSetBegin();
+                  struct.propertiesToExclude = new HashSet<String>(2*_set192.size);
+                  for (int _i193 = 0; _i193 < _set192.size; ++_i193)
                   {
-                    String _elem162; // optional
-                    _elem162 = iprot.readString();
-                    struct.propertiesToExclude.add(_elem162);
+                    String _elem194; // required
+                    _elem194 = iprot.readString();
+                    struct.propertiesToExclude.add(_elem194);
                   }
                   iprot.readSetEnd();
                 }
@@ -14958,10 +15350,10 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(PROPERTIES_TO_SET_FIELD_DESC);
           {
             oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.propertiesToSet.size()));
-            for (Map.Entry<String, String> _iter163 : struct.propertiesToSet.entrySet())
+            for (Map.Entry<String, String> _iter195 : struct.propertiesToSet.entrySet())
             {
-              oprot.writeString(_iter163.getKey());
-              oprot.writeString(_iter163.getValue());
+              oprot.writeString(_iter195.getKey());
+              oprot.writeString(_iter195.getValue());
             }
             oprot.writeMapEnd();
           }
@@ -14971,9 +15363,9 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(PROPERTIES_TO_EXCLUDE_FIELD_DESC);
           {
             oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, struct.propertiesToExclude.size()));
-            for (String _iter164 : struct.propertiesToExclude)
+            for (String _iter196 : struct.propertiesToExclude)
             {
-              oprot.writeString(_iter164);
+              oprot.writeString(_iter196);
             }
             oprot.writeSetEnd();
           }
@@ -15031,19 +15423,19 @@ import org.slf4j.LoggerFactory;
         if (struct.isSetPropertiesToSet()) {
           {
             oprot.writeI32(struct.propertiesToSet.size());
-            for (Map.Entry<String, String> _iter165 : struct.propertiesToSet.entrySet())
+            for (Map.Entry<String, String> _iter197 : struct.propertiesToSet.entrySet())
             {
-              oprot.writeString(_iter165.getKey());
-              oprot.writeString(_iter165.getValue());
+              oprot.writeString(_iter197.getKey());
+              oprot.writeString(_iter197.getValue());
             }
           }
         }
         if (struct.isSetPropertiesToExclude()) {
           {
             oprot.writeI32(struct.propertiesToExclude.size());
-            for (String _iter166 : struct.propertiesToExclude)
+            for (String _iter198 : struct.propertiesToExclude)
             {
-              oprot.writeString(_iter166);
+              oprot.writeString(_iter198);
             }
           }
         }
@@ -15071,28 +15463,28 @@ import org.slf4j.LoggerFactory;
         }
         if (incoming.get(4)) {
           {
-            org.apache.thrift.protocol.TMap _map167 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32());
-            struct.propertiesToSet = new HashMap<String,String>(2*_map167.size);
-            for (int _i168 = 0; _i168 < _map167.size; ++_i168)
+            org.apache.thrift.protocol.TMap _map199 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32());
+            struct.propertiesToSet = new HashMap<String,String>(2*_map199.size);
+            for (int _i200 = 0; _i200 < _map199.size; ++_i200)
             {
-              String _key169; // required
-              String _val170; // required
-              _key169 = iprot.readString();
-              _val170 = iprot.readString();
-              struct.propertiesToSet.put(_key169, _val170);
+              String _key201; // required
+              String _val202; // required
+              _key201 = iprot.readString();
+              _val202 = iprot.readString();
+              struct.propertiesToSet.put(_key201, _val202);
             }
           }
           struct.setPropertiesToSetIsSet(true);
         }
         if (incoming.get(5)) {
           {
-            org.apache.thrift.protocol.TSet _set171 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
-            struct.propertiesToExclude = new HashSet<String>(2*_set171.size);
-            for (int _i172 = 0; _i172 < _set171.size; ++_i172)
+            org.apache.thrift.protocol.TSet _set203 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
+            struct.propertiesToExclude = new HashSet<String>(2*_set203.size);
+            for (int _i204 = 0; _i204 < _set203.size; ++_i204)
             {
-              String _elem173; // optional
-              _elem173 = iprot.readString();
-              struct.propertiesToExclude.add(_elem173);
+              String _elem205; // required
+              _elem205 = iprot.readString();
+              struct.propertiesToExclude.add(_elem205);
             }
           }
           struct.setPropertiesToExcludeIsSet(true);
@@ -16596,14 +16988,14 @@ import org.slf4j.LoggerFactory;
             case 5: // ITERATORS
               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                 {
-                  org.apache.thrift.protocol.TList _list174 = iprot.readListBegin();
-                  struct.iterators = new ArrayList<IteratorSetting>(_list174.size);
-                  for (int _i175 = 0; _i175 < _list174.size; ++_i175)
+                  org.apache.thrift.protocol.TList _list206 = iprot.readListBegin();
+                  struct.iterators = new ArrayList<IteratorSetting>(_list206.size);
+                  for (int _i207 = 0; _i207 < _list206.size; ++_i207)
                   {
-                    IteratorSetting _elem176; // optional
-                    _elem176 = new IteratorSetting();
-                    _elem176.read(iprot);
-                    struct.iterators.add(_elem176);
+                    IteratorSetting _elem208; // required
+                    _elem208 = new IteratorSetting();
+                    _elem208.read(iprot);
+                    struct.iterators.add(_elem208);
                   }
                   iprot.readListEnd();
                 }
@@ -16667,9 +17059,9 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(ITERATORS_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.iterators.size()));
-            for (IteratorSetting _iter177 : struct.iterators)
+            for (IteratorSetting _iter209 : struct.iterators)
             {
-              _iter177.write(oprot);
+              _iter209.write(oprot);
             }
             oprot.writeListEnd();
           }
@@ -16736,9 +17128,9 @@ import org.slf4j.LoggerFactory;
         if (struct.isSetIterators()) {
           {
             oprot.writeI32(struct.iterators.size());
-            for (IteratorSetting _iter178 : struct.iterators)
+            for (IteratorSetting _iter210 : struct.iterators)
             {
-              _iter178.write(oprot);
+              _iter210.write(oprot);
             }
           }
         }
@@ -16772,14 +17164,14 @@ import org.slf4j.LoggerFactory;
         }
         if (incoming.get(4)) {
           {
-            org.apache.thrift.protocol.TList _list179 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
-            struct.iterators = new ArrayList<IteratorSetting>(_list179.size);
-            for (int _i180 = 0; _i180 < _list179.size; ++_i180)
+            org.apache.thrift.protocol.TList _list211 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+            struct.iterators = new ArrayList<IteratorSetting>(_list211.size);
+            for (int _i212 = 0; _i212 < _list211.size; ++_i212)
             {
-              IteratorSetting _elem181; // optional
-              _elem181 = new IteratorSetting();
-              _elem181.read(iprot);
-              struct.iterators.add(_elem181);
+              IteratorSetting _elem213; // required
+              _elem213 = new IteratorSetting();
+              _elem213.read(iprot);
+              struct.iterators.add(_elem213);
             }
           }
           struct.setIteratorsIsSet(true);
@@ -24768,13 +25160,13 @@ import org.slf4j.LoggerFactory;
             case 2: // TABLES
               if (schemeField.type == org.apache.thrift.protocol.TType.SET) {
                 {
-                  org.apache.thrift.protocol.TSet _set182 = iprot.readSetBegin();
-                  struct.tables = new HashSet<String>(2*_set182.size);
-                  for (int _i183 = 0; _i183 < _set182.size; ++_i183)
+                  org.apache.thrift.protocol.TSet _set214 = iprot.readSetBegin();
+                  struct.tables = new HashSet<String>(2*_set214.size);
+                  for (int _i215 = 0; _i215 < _set214.size; ++_i215)
                   {
-                    String _elem184; // optional
-                    _elem184 = iprot.readString();
-                    struct.tables.add(_elem184);
+                    String _elem216; // required
+                    _elem216 = iprot.readString();
+                    struct.tables.add(_elem216);
                   }
                   iprot.readSetEnd();
                 }
@@ -24807,9 +25199,9 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(TABLES_FIELD_DESC);
           {
             oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, struct.tables.size()));
-            for (String _iter185 : struct.tables)
+            for (String _iter217 : struct.tables)
             {
-              oprot.writeString(_iter185);
+              oprot.writeString(_iter217);
             }
             oprot.writeSetEnd();
           }
@@ -24846,9 +25238,9 @@ import org.slf4j.LoggerFactory;
         if (struct.isSetTables()) {
           {
             oprot.writeI32(struct.tables.size());
-            for (String _iter186 : struct.tables)
+            for (String _iter218 : struct.tables)
             {
-              oprot.writeString(_iter186);
+              oprot.writeString(_iter218);
             }
           }
         }
@@ -24864,13 +25256,13 @@ import org.slf4j.LoggerFactory;
         }
         if (incoming.get(1)) {
           {
-            org.apache.thrift.protocol.TSet _set187 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
-            struct.tables = new HashSet<String>(2*_set187.size);
-            for (int _i188 = 0; _i188 < _set187.size; ++_i188)
+            org.apache.thrift.protocol.TSet _set219 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
+            struct.tables = new HashSet<String>(2*_set219.size);
+            for (int _i220 = 0; _i220 < _set219.size; ++_i220)
             {
-              String _elem189; // optional
-              _elem189 = iprot.readString();
-              struct.tables.add(_elem189);
+              String _elem221; // required
+              _elem221 = iprot.readString();
+              struct.tables.add(_elem221);
             }
           }
           struct.setTablesIsSet(true);
@@ -25420,14 +25812,14 @@ import org.slf4j.LoggerFactory;
             case 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                 {
-                  org.apache.thrift.protocol.TList _list190 = iprot.readListBegin();
-                  struct.success = new ArrayList<DiskUsage>(_list190.size);
-                  for (int _i191 = 0; _i191 < _list190.size; ++_i191)
+                  org.apache.thrift.protocol.TList _list222 = iprot.readListBegin();
+                  struct.success = new ArrayList<DiskUsage>(_list222.size);
+                  for (int _i223 = 0; _i223 < _list222.size; ++_i223)
                   {
-                    DiskUsage _elem192; // optional
-                    _elem192 = new DiskUsage();
-                    _elem192.read(iprot);
-                    struct.success.add(_elem192);
+                    DiskUsage _elem224; // required
+                    _elem224 = new DiskUsage();
+                    _elem224.read(iprot);
+                    struct.success.add(_elem224);
                   }
                   iprot.readListEnd();
                 }
@@ -25482,9 +25874,9 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
-            for (DiskUsage _iter193 : struct.success)
+            for (DiskUsage _iter225 : struct.success)
             {
-              _iter193.write(oprot);
+              _iter225.write(oprot);
             }
             oprot.writeListEnd();
           }
@@ -25539,9 +25931,9 @@ import org.slf4j.LoggerFactory;
         if (struct.isSetSuccess()) {
           {
             oprot.writeI32(struct.success.size());
-            for (DiskUsage _iter194 : struct.success)
+            for (DiskUsage _iter226 : struct.success)
             {
-              _iter194.write(oprot);
+              _iter226.write(oprot);
             }
           }
         }
@@ -25562,14 +25954,14 @@ import org.slf4j.LoggerFactory;
         BitSet incoming = iprot.readBitSet(4);
         if (incoming.get(0)) {
           {
-            org.apache.thrift.protocol.TList _list195 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
-            struct.success = new ArrayList<DiskUsage>(_list195.size);
-            for (int _i196 = 0; _i196 < _list195.size; ++_i196)
+            org.apache.thrift.protocol.TList _list227 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+            struct.success = new ArrayList<DiskUsage>(_list227.size);
+            for (int _i228 = 0; _i228 < _list227.size; ++_i228)
             {
-              DiskUsage _elem197; // optional
-              _elem197 = new DiskUsage();
-              _elem197.read(iprot);
-              struct.success.add(_elem197);
+              DiskUsage _elem229; // required
+              _elem229 = new DiskUsage();
+              _elem229.read(iprot);
+              struct.success.add(_elem229);
             }
           }
           struct.setSuccessIsSet(true);
@@ -26608,25 +27000,25 @@ import org.slf4j.LoggerFactory;
             case 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
                 {
-                  org.apache.thrift.protocol.TMap _map198 = iprot.readMapBegin();
-                  struct.success = new HashMap<String,Set<String>>(2*_map198.size);
-                  for (int _i199 = 0; _i199 < _map198.size; ++_i199)
+                  org.apache.thrift.protocol.TMap _map230 = iprot.readMapBegin();
+                  struct.success = new HashMap<String,Set<String>>(2*_map230.size);
+                  for (int _i231 = 0; _i231 < _map230.size; ++_i231)
                   {
-                    String _key200; // required
-                    Set<String> _val201; // required
-                    _key200 = iprot.readString();
+                    String _key232; // required
+                    Set<String> _val233; // required
+                    _key232 = iprot.readString();
                     {
-                      org.apache.thrift.protocol.TSet _set202 = iprot.readSetBegin();
-                      _val201 = new HashSet<String>(2*_set202.size);
-                      for (int _i203 = 0; _i203 < _set202.size; ++_i203)
+                      org.apache.thrift.protocol.TSet _set234 = iprot.readSetBegin();
+                      _val233 = new HashSet<String>(2*_set234.size);
+                      for (int _i235 = 0; _i235 < _set234.size; ++_i235)
                       {
-                        String _elem204; // optional
-                        _elem204 = iprot.readString();
-                        _val201.add(_elem204);
+                        String _elem236; // required
+                        _elem236 = iprot.readString();
+                        _val233.add(_elem236);
                       }
                       iprot.readSetEnd();
                     }
-                    struct.success.put(_key200, _val201);
+                    struct.success.put(_key232, _val233);
                   }
                   iprot.readMapEnd();
                 }
@@ -26681,14 +27073,14 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           {
             oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.SET, struct.success.size()));
-            for (Map.Entry<String, Set<String>> _iter205 : struct.success.entrySet())
+            for (Map.Entry<String, Set<String>> _iter237 : struct.success.entrySet())
             {
-              oprot.writeString(_iter205.getKey());
+              oprot.writeString(_iter237.getKey());
               {
-                oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, _iter205.getValue().size()));
-                for (String _iter206 : _iter205.getValue())
+                oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, _iter237.getValue().size()));
+                for (String _iter238 : _iter237.getValue())
                 {
-                  oprot.writeString(_iter206);
+                  oprot.writeString(_iter238);
                 }
                 oprot.writeSetEnd();
               }
@@ -26746,14 +27138,14 @@ import org.slf4j.LoggerFactory;
         if (struct.isSetSuccess()) {
           {
             oprot.writeI32(struct.success.size());
-            for (Map.Entry<String, Set<String>> _iter207 : struct.success.entrySet())
+            for (Map.Entry<String, Set<String>> _iter239 : struct.success.entrySet())
             {
-              oprot.writeString(_iter207.getKey());
+              oprot.writeString(_iter239.getKey());
               {
-                oprot.writeI32(_iter207.getValue().size());
-                for (String _iter208 : _iter207.getValue())
+                oprot.writeI32(_iter239.getValue().size());
+                for (String _iter240 : _iter239.getValue())
                 {
-                  oprot.writeString(_iter208);
+                  oprot.writeString(_iter240);
                 }
               }
             }
@@ -26776,24 +27168,24 @@ import org.slf4j.LoggerFactory;
         BitSet incoming = iprot.readBitSet(4);
         if (incoming.get(0)) {
           {
-            org.apache.thrift.protocol.TMap _map209 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.SET, iprot.readI32());
-            struct.success = new HashMap<String,Set<String>>(2*_map209.size);
-            for (int _i210 = 0; _i210 < _map209.size; ++_i210)
+            org.apache.thrift.protocol.TMap _map241 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.SET, iprot.readI32());
+            struct.success = new HashMap<String,Set<String>>(2*_map241.size);
+            for (int _i242 = 0; _i242 < _map241.size; ++_i242)
             {
-              String _key211; // required
-              Set<String> _val212; // required
-              _key211 = iprot.readString();
+              String _key243; // required
+              Set<String> _val244; // required
+              _key243 = iprot.readString();
               {
-                org.apache.thrift.protocol.TSet _set213 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
-                _val212 = new HashSet<String>(2*_set213.size);
-                for (int _i214 = 0; _i214 < _set213.size; ++_i214)
+                org.apache.thrift.protocol.TSet _set245 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
+                _val244 = new HashSet<String>(2*_set245.size);
+                for (int _i246 = 0; _i246 < _set245.size; ++_i246)
                 {
-                  String _elem215; // optional
-                  _elem215 = iprot.readString();
-                  _val212.add(_elem215);
+                  String _elem247; // required
+                  _elem247 = iprot.readString();
+                  _val244.add(_elem247);
                 }
               }
-              struct.success.put(_key211, _val212);
+              struct.success.put(_key243, _val244);
             }
           }
           struct.setSuccessIsSet(true);
@@ -28982,13 +29374,13 @@ import org.slf4j.LoggerFactory;
             case 3: // AUTHS
               if (schemeField.type == org.apache.thrift.protocol.TType.SET) {
                 {
-                  org.apache.thrift.protocol.TSet _set216 = iprot.readSetBegin();
-                  struct.auths = new HashSet<ByteBuffer>(2*_set216.size);
-                  for (int _i217 = 0; _i217 < _set216.size; ++_i217)
+                  org.apache.thrift.protocol.TSet _set248 = iprot.readSetBegin();
+                  struct.auths = new HashSet<ByteBuffer>(2*_set248.size);
+                  for (int _i249 = 0; _i249 < _set248.size; ++_i249)
                   {
-                    ByteBuffer _elem218; // optional
-                    _elem218 = iprot.readBinary();
-                    struct.auths.add(_elem218);
+                    ByteBuffer _elem250; // required
+                    _elem250 = iprot.readBinary();
+                    struct.auths.add(_elem250);
                   }
                   iprot.readSetEnd();
                 }
@@ -29058,9 +29450,9 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(AUTHS_FIELD_DESC);
           {
             oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, struct.auths.size()));
-            for (ByteBuffer _iter219 : struct.auths)
+            for (ByteBuffer _iter251 : struct.auths)
             {
-              oprot.writeBinary(_iter219);
+              oprot.writeBinary(_iter251);
             }
             oprot.writeSetEnd();
           }
@@ -29131,9 +29523,9 @@ import org.slf4j.LoggerFactory;
         if (struct.isSetAuths()) {
           {
             oprot.writeI32(struct.auths.size());
-            for (ByteBuffer _iter220 : struct.auths)
+            for (ByteBuffer _iter252 : struct.auths)
             {
-              oprot.writeBinary(_iter220);
+              oprot.writeBinary(_iter252);
             }
           }
         }
@@ -29165,13 +29557,13 @@ import org.slf4j.LoggerFactory;
         }
         if (incoming.get(2)) {
           {
-            org.apache.thrift.protocol.TSet _set221 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
-            struct.auths = new HashSet<ByteBuffer>(2*_set221.size);
-            for (int _i222 = 0; _i222 < _set221.size; ++_i222)
+            org.apache.thrift.protocol.TSet _set253 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
+            struct.auths = new HashSet<ByteBuffer>(2*_set253.size);
+            for (int _i254 = 0; _i254 < _set253.size; ++_i254)
             {
-              ByteBuffer _elem223; // optional
-              _elem223 = iprot.readBinary();
-              struct.auths.add(_elem223);
+              ByteBuffer _elem255; // required
+              _elem255 = iprot.readBinary();
+              struct.auths.add(_elem255);
             }
           }
           struct.setAuthsIsSet(true);
@@ -30878,15 +31270,15 @@ import org.slf4j.LoggerFactory;
             case 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
                 {
-                  org.apache.thrift.protocol.TMap _map224 = iprot.readMapBegin();
-                  struct.success = new HashMap<String,String>(2*_map224.size);
-                  for (int _i225 = 0; _i225 < _map224.size; ++_i225)
+                  org.apache.thrift.protocol.TMap _map256 = iprot.readMapBegin();
+                  struct.success = new HashMap<String,String>(2*_map256.size);
+                  for (int _i257 = 0; _i257 < _map256.size; ++_i257)
                   {
-                    String _key226; // required
-                    String _val227; // required
-                    _key226 = iprot.readString();
-                    _val227 = iprot.readString();
-                    struct.success.put(_key226, _val227);
+                    String _key258; // required
+                    String _val259; // required
+                    _key258 = iprot.readString();
+                    _val259 = iprot.readString();
+                    struct.success.put(_key258, _val259);
                   }
                   iprot.readMapEnd();
                 }
@@ -30941,10 +31333,10 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           {
             oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.success.size()));
-            for (Map.Entry<String, String> _iter228 : struct.success.entrySet())
+            for (Map.Entry<String, String> _iter260 : struct.success.entrySet())
             {
-              oprot.writeString(_iter228.getKey());
-              oprot.writeString(_iter228.getValue());
+              oprot.writeString(_iter260.getKey());
+              oprot.writeString(_iter260.getValue());
             }
             oprot.writeMapEnd();
           }
@@ -30999,10 +31391,10 @@ import org.slf4j.LoggerFactory;
         if (struct.isSetSuccess()) {
           {
             oprot.writeI32(struct.success.size());
-            for (Map.Entry<String, String> _iter229 : struct.success.entrySet())
+            for (Map.Entry<String, String> _iter261 : struct.success.entrySet())
             {
-              oprot.writeString(_iter229.getKey());
-              oprot.writeString(_iter229.getValue());
+              oprot.writeString(_iter261.getKey());
+              oprot.writeString(_iter261.getValue());
             }
           }
         }
@@ -31023,15 +31415,15 @@ import org.slf4j.LoggerFactory;
         BitSet incoming = iprot.readBitSet(4);
         if (incoming.get(0)) {
           {
-            org.apache.thrift.protocol.TMap _map230 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32());
-            struct.success = new HashMap<String,String>(2*_map230.size);
-            for (int _i231 = 0; _i231 < _map230.size; ++_i231)
+            org.apache.thrift.protocol.TMap _map262 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32());
+            struct.success = new HashMap<String,String>(2*_map262.size);
+            for (int _i263 = 0; _i263 < _map262.size; ++_i263)
             {
-              String _key232; // required
-              String _val233; // required
-              _key232 = iprot.readString();
-              _val233 = iprot.readString();
-              struct.success.put(_key232, _val233);
+              String _key264; // required
+              String _val265; // required
+              _key264 = iprot.readString();
+              _val265 = iprot.readString();
+              struct.success.put(_key264, _val265);
             }
           }
           struct.setSuccessIsSet(true);
@@ -34609,13 +35001,13 @@ import org.slf4j.LoggerFactory;
             case 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                 {
-                  org.apache.thrift.protocol.TList _list234 = iprot.readListBegin();
-                  struct.success = new ArrayList<ByteBuffer>(_list234.size);
-                  for (int _i235 = 0; _i235 < _list234.size; ++_i235)
+                  org.apache.thrift.protocol.TList _list266 = iprot.readListBegin();
+                  struct.success = new ArrayList<ByteBuffer>(_list266.size);
+                  for (int _i267 = 0; _i267 < _list266.size; ++_i267)
                   {
-                    ByteBuffer _elem236; // optional
-                    _elem236 = iprot.readBinary();
-                    struct.success.add(_elem236);
+                    ByteBuffer _elem268; // required
+                    _elem268 = iprot.readBinary();
+                    struct.success.add(_elem268);
                   }
                   iprot.readListEnd();
                 }
@@ -34670,9 +35062,9 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size()));
-            for (ByteBuffer _iter237 : struct.success)
+            for (ByteBuffer _iter269 : struct.success)
             {
-              oprot.writeBinary(_iter237);
+              oprot.writeBinary(_iter269);
             }
             oprot.writeListEnd();
           }
@@ -34727,9 +35119,9 @@ import org.slf4j.LoggerFactory;
         if (struct.isSetSuccess()) {
           {
             oprot.writeI32(struct.success.size());
-            for (ByteBuffer _iter238 : struct.success)
+            for (ByteBuffer _iter270 : struct.success)
             {
-              oprot.writeBinary(_iter238);
+              oprot.writeBinary(_iter270);
             }
           }
         }
@@ -34750,13 +35142,13 @@ import org.slf4j.LoggerFactory;
         BitSet incoming = iprot.readBitSet(4);
         if (incoming.get(0)) {
           {
-            org.apache.thrift.protocol.TList _list239 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
-            struct.success = new ArrayList<ByteBuffer>(_list239.size);
-            for (int _i240 = 0; _i240 < _list239.size; ++_i240)
+            org.apache.thrift.protocol.TList _list271 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
+            struct.success = new ArrayList<ByteBuffer>(_list271.size);
+            for (int _i272 = 0; _i272 < _list271.size; ++_i272)
             {
-              ByteBuffer _elem241; // optional
-              _elem241 = iprot.readBinary();
-              struct.success.add(_elem241);
+              ByteBuffer _elem273; // required
+              _elem273 = iprot.readBinary();
+              struct.success.add(_elem273);
             }
           }
           struct.setSuccessIsSet(true);
@@ -35455,13 +35847,13 @@ import org.slf4j.LoggerFactory;
             case 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.SET) {
                 {
-                  org.apache.thrift.protocol.TSet _set242 = iprot.readSetBegin();
-                  struct.success = new HashSet<String>(2*_set242.size);
-                  for (int _i243 = 0; _i243 < _set242.size; ++_i243)
+                  org.apache.thrift.protocol.TSet _set274 = iprot.readSetBegin();
+                  struct.success = new HashSet<String>(2*_set274.size);
+                  for (int _i275 = 0; _i275 < _set274.size; ++_i275)
                   {
-                    String _elem244; // optional
-                    _elem244 = iprot.readString();
-                    struct.success.add(_elem244);
+                    String _elem276; // required
+                    _elem276 = iprot.readString();
+                    struct.success.add(_elem276);
                   }
                   iprot.readSetEnd();
                 }
@@ -35489,9 +35881,9 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           {
             oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, struct.success.size()));
-            for (String _iter245 : struct.success)
+            for (String _iter277 : struct.success)
             {
-              oprot.writeString(_iter245);
+              oprot.writeString(_iter277);
             }
             oprot.writeSetEnd();
           }
@@ -35522,9 +35914,9 @@ import org.slf4j.LoggerFactory;
         if (struct.isSetSuccess()) {
           {
             oprot.writeI32(struct.success.size());
-            for (String _iter246 : struct.success)
+            for (String _iter278 : struct.success)
             {
-              oprot.writeString(_iter246);
+              oprot.writeString(_iter278);
             }
           }
         }
@@ -35536,13 +35928,13 @@ import org.slf4j.LoggerFactory;
         BitSet incoming = iprot.readBitSet(1);
         if (incoming.get(0)) {
           {
-            org.apache.thrift.protocol.TSet _set247 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
-            struct.success = new HashSet<String>(2*_set247.size);
-            for (int _i248 = 0; _i248 < _set247.size; ++_i248)
+            org.apache.thrift.protocol.TSet _set279 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
+            struct.success = new HashSet<String>(2*_set279.size);
+            for (int _i280 = 0; _i280 < _set279.size; ++_i280)
             {
-              String _elem249; // optional
-              _elem249 = iprot.readString();
-              struct.success.add(_elem249);
+              String _elem281; // required
+              _elem281 = iprot.readString();
+              struct.success.add(_elem281);
             }
           }
           struct.setSuccessIsSet(true);
@@ -36566,25 +36958,25 @@ import org.slf4j.LoggerFactory;
             case 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
                 {
-                  org.apache.thrift.protocol.TMap _map250 = iprot.readMapBegin();
-                  struct.success = new HashMap<String,Set<IteratorScope>>(2*_map250.size);
-                  for (int _i251 = 0; _i251 < _map250.size; ++_i251)
+                  org.apache.thrift.protocol.TMap _map282 = iprot.readMapBegin();
+                  struct.success = new HashMap<String,Set<IteratorScope>>(2*_map282.size);
+                  for (int _i283 = 0; _i283 < _map282.size; ++_i283)
                   {
-                    String _key252; // required
-                    Set<IteratorScope> _val253; // required
-                    _key252 = iprot.readString();
+                    String _key284; // required
+                    Set<IteratorScope> _val285; // required
+                    _key284 = iprot.readString();
                     {
-                      org.apache.thrift.protocol.TSet _set254 = iprot.readSetBegin();
-                      _val253 = new HashSet<IteratorScope>(2*_set254.size);
-                      for (int _i255 = 0; _i255 < _set254.size; ++_i255)
+                      org.apache.thrift.protocol.TSet _set286 = iprot.readSetBegin();
+                      _val285 = new HashSet<IteratorScope>(2*_set286.size);
+                      for (int _i287 = 0; _i287 < _set286.size; ++_i287)
                       {
-                        IteratorScope _elem256; // optional
-                        _elem256 = IteratorScope.findByValue(iprot.readI32());
-                        _val253.add(_elem256);
+                        IteratorScope _elem288; // required
+                        _elem288 = IteratorScope.findByValue(iprot.readI32());
+                        _val285.add(_elem288);
                       }
                       iprot.readSetEnd();
                     }
-                    struct.success.put(_key252, _val253);
+                    struct.success.put(_key284, _val285);
                   }
                   iprot.readMapEnd();
                 }
@@ -36639,14 +37031,14 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           {
             oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.SET, struct.success.size()));
-            for (Map.Entry<String, Set<IteratorScope>> _iter257 : struct.success.entrySet())
+            for (Map.Entry<String, Set<IteratorScope>> _iter289 : struct.success.entrySet())
             {
-              oprot.writeString(_iter257.getKey());
+              oprot.writeString(_iter289.getKey());
               {
-                oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, _iter257.getValue().size()));
-                for (IteratorScope _iter258 : _iter257.getValue())
+                oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, _iter289.getValue().size()));
+                for (IteratorScope _iter290 : _iter289.getValue())
                 {
-                  oprot.writeI32(_iter258.getValue());
+                  oprot.writeI32(_iter290.getValue());
                 }
                 oprot.writeSetEnd();
               }
@@ -36704,14 +37096,14 @@ import org.slf4j.LoggerFactory;
         if (struct.isSetSuccess()) {
           {
             oprot.writeI32(struct.success.size());
-            for (Map.Entry<String, Set<IteratorScope>> _iter259 : struct.success.entrySet())
+            for (Map.Entry<String, Set<IteratorScope>> _iter291 : struct.success.entrySet())
             {
-              oprot.writeString(_iter259.getKey());
+              oprot.writeString(_iter291.getKey());
               {
-                oprot.writeI32(_iter259.getValue().size());
-                for (IteratorScope _iter260 : _iter259.getValue())
+                oprot.writeI32(_iter291.getValue().size());
+                for (IteratorScope _iter292 : _iter291.getValue())
                 {
-                  oprot.writeI32(_iter260.getValue());
+                  oprot.writeI32(_iter292.getValue());
                 }
               }
             }
@@ -36734,24 +37126,24 @@ import org.slf4j.LoggerFactory;
         BitSet incoming = iprot.readBitSet(4);
         if (incoming.get(0)) {
           {
-            org.apache.thrift.protocol.TMap _map261 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.SET, iprot.readI32());
-            struct.success = new HashMap<String,Set<IteratorScope>>(2*_map261.size);
-            for (int _i262 = 0; _i262 < _map261.size; ++_i262)
+            org.apache.thrift.protocol.TMap _map293 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.SET, iprot.readI32());
+            struct.success = new HashMap<String,Set<IteratorScope>>(2*_map293.size);
+            for (int _i294 = 0; _i294 < _map293.size; ++_i294)
             {
-              String _key263; // required
-              Set<IteratorScope> _val264; // required
-              _key263 = iprot.readString();
+              String _key295; // required
+              Set<IteratorScope> _val296; // required
+              _key295 = iprot.readString();
               {
-                org.apache.thrift.protocol.TSet _set265 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, iprot.readI32());
-                _val264 = new HashSet<IteratorScope>(2*_set265.size);
-                for (int _i266 = 0; _i266 < _set265.size; ++_i266)
+                org.apache.thrift.protocol.TSet _set297 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, iprot.readI32());
+                _val296 = new HashSet<IteratorScope>(2*_set297.size);
+                for (int _i298 = 0; _i298 < _set297.size; ++_i298)
                 {
-                  IteratorScope _elem267; // optional
-                  _elem267 = IteratorScope.findByValue(iprot.readI32());
-                  _val264.add(_elem267);
+                  IteratorScope _elem299; // required
+                  _elem299 = IteratorScope.findByValue(iprot.readI32());
+                  _val296.add(_elem299);
                 }
               }
-              struct.success.put(_key263, _val264);
+              struct.success.put(_key295, _val296);
             }
           }
           struct.setSuccessIsSet(true);
@@ -37786,15 +38178,15 @@ import org.slf4j.LoggerFactory;
             case 0: // SUCCESS
               if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
                 {
-                  org.apache.thrift.protocol.TMap _map268 = iprot.readMapBegin();
-                  struct.success = new HashMap<String,Integer>(2*_map268.size);
-                  for (int _i269 = 0; _i269 < _map268.size; ++_i269)
+                  org.apache.thrift.protocol.TMap _map300 = iprot.readMapBegin();
+                  struct.success = new HashMap<String,Integer>(2*_map300.size);
+                  for (int _i301 = 0; _i301 < _map300.size; ++_i301)
                   {
-                    String _key270; // required
-                    int _val271; // required
-                    _key270 = iprot.readString();
-                    _val271 = iprot.readI32();
-                    struct.success.put(_key270, _val271);
+                    String _key302; // required
+                    int _val303; // required
+                    _key302 = iprot.readString();
+                    _val303 = iprot.readI32();
+                    struct.success.put(_key302, _val303);
                   }
                   iprot.readMapEnd();
                 }
@@ -37849,10 +38241,10 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
           {
             oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I32, struct.success.size()));
-            for (Map.Entry<String, Integer> _iter272 : struct.success.entrySet())
+            for (Map.Entry<String, Integer> _iter304 : struct.success.entrySet())
             {
-              oprot.writeString(_iter272.getKey());
-              oprot.writeI32(_iter272.getValue());
+              oprot.writeString(_iter304.getKey());
+              oprot.writeI32(_iter304.getValue());
             }
             oprot.writeMapEnd();
           }
@@ -37907,10 +38299,10 @@ import org.slf4j.LoggerFactory;
         if (struct.isSetSuccess()) {
           {
             oprot.writeI32(struct.success.size());
-            for (Map.Entry<String, Integer> _iter273 : struct.success.entrySet())
+            for (Map.Entry<String, Integer> _iter305 : struct.success.entrySet())
             {
-              oprot.writeString(_iter273.getKey());
-              oprot.writeI32(_iter273.getValue());
+              oprot.writeString(_iter305.getKey());
+              oprot.writeI32(_iter305.getValue());
             }
           }
         }
@@ -37931,15 +38323,15 @@ import org.slf4j.LoggerFactory;
         BitSet incoming = iprot.readBitSet(4);
         if (incoming.get(0)) {
           {
-            org.apache.thrift.protocol.TMap _map274 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I32, iprot.readI32());
-            struct.success = new HashMap<String,Integer>(2*_map274.size);
-            for (int _i275 = 0; _i275 < _map274.size; ++_i275)
+            org.apache.thrift.protocol.TMap _map306 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I32, iprot.readI32());
+            struct.success = new HashMap<String,Integer>(2*_map306.size);
+            for (int _i307 = 0; _i307 < _map306.size; ++_i307)
             {
-              String _key276; // required
-              int _val277; // required
-              _key276 = iprot.readString();
-              _val277 = iprot.readI32();
-              struct.success.put(_key276, _val277);
+              String _key308; // required
+              int _val309; // required
+              _key308 = iprot.readString();
+              _val309 = iprot.readI32();
+              struct.success.put(_key308, _val309);
             }
           }
           struct.setSuccessIsSet(true);
@@ -42959,13 +43351,13 @@ import org.slf4j.LoggerFactory;
             case 4: // SCOPES
               if (schemeField.type == org.apache.thrift.protocol.TType.SET) {
                 {
-                  org.apache.thrift.protocol.TSet _set278 = iprot.readSetBegin();
-                  struct.scopes = new HashSet<IteratorScope>(2*_set278.size);
-                  for (int _i279 = 0; _i279 < _set278.size; ++_i279)
+                  org.apache.thrift.protocol.TSet _set310 = iprot.readSetBegin();
+                  struct.scopes = new HashSet<IteratorScope>(2*_set310.size);
+                  for (int _i311 = 0; _i311 < _set310.size; ++_i311)
                   {
-                    IteratorScope _elem280; // optional
-                    _elem280 = IteratorScope.findByValue(iprot.readI32());
-                    struct.scopes.add(_elem280);
+                    IteratorScope _elem312; // required
+                    _elem312 = IteratorScope.findByValue(iprot.readI32());
+                    struct.scopes.add(_elem312);
                   }
                   iprot.readSetEnd();
                 }
@@ -43008,9 +43400,9 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(SCOPES_FIELD_DESC);
           {
             oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, struct.scopes.size()));
-            for (IteratorScope _iter281 : struct.scopes)
+            for (IteratorScope _iter313 : struct.scopes)
             {
-              oprot.writeI32(_iter281.getValue());
+              oprot.writeI32(_iter313.getValue());
             }
             oprot.writeSetEnd();
           }
@@ -43059,9 +43451,9 @@ import org.slf4j.LoggerFactory;
         if (struct.isSetScopes()) {
           {
             oprot.writeI32(struct.scopes.size());
-            for (IteratorScope _iter282 : struct.scopes)
+            for (IteratorScope _iter314 : struct.scopes)
             {
-              oprot.writeI32(_iter282.getValue());
+              oprot.writeI32(_iter314.getValue());
             }
           }
         }
@@ -43085,13 +43477,13 @@ import org.slf4j.LoggerFactory;
         }
         if (incoming.get(3)) {
           {
-            org.apache.thrift.protocol.TSet _set283 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, iprot.readI32());
-            struct.scopes = new HashSet<IteratorScope>(2*_set283.size);
-            for (int _i284 = 0; _i284 < _set283.size; ++_i284)
+            org.apache.thrift.protocol.TSet _set315 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, iprot.readI32());
+            struct.scopes = new HashSet<IteratorScope>(2*_set315.size);
+            for (int _i316 = 0; _i316 < _set315.size; ++_i316)
             {
-              IteratorScope _elem285; // optional
-              _elem285 = IteratorScope.findByValue(iprot.readI32());
-              struct.scopes.add(_elem285);
+              IteratorScope _elem317; // required
+              _elem317 = IteratorScope.findByValue(iprot.readI32());
+              struct.scopes.add(_elem317);
             }
           }
           struct.setScopesIsSet(true);
@@ -46512,25 +46904,25 @@ import org.slf4j.LoggerFactory;
             case 3: // GROUPS
               if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
                 {
-                  org.apache.thrift.protocol.TMap _map286 = iprot.readMapBegin();
-                  struct.groups = new HashMap<String,Set<String>>(2*_map286.size);
-                  for (int _i287 = 0; _i287 < _map286.size; ++_i287)
+                  org.apache.thrift.protocol.TMap _map318 = iprot.readMapBegin();
+                  struct.groups = new HashMap<String,Set<String>>(2*_map318.size);
+                  for (int _i319 = 0; _i319 < _map318.size; ++_i319)
                   {
-                    String _key288; // required
-                    Set<String> _val289; // required
-                    _key288 = iprot.readString();
+                    String _key320; // required
+                    Set<String> _val321; // required
+                    _key320 = iprot.readString();
                     {
-                      org.apache.thrift.protocol.TSet _set290 = iprot.readSetBegin();
-                      _val289 = new HashSet<String>(2*_set290.size);
-                      for (int _i291 = 0; _i291 < _set290.size; ++_i291)
+                      org.apache.thrift.protocol.TSet _set322 = iprot.readSetBegin();
+                      _val321 = new HashSet<String>(2*_set322.size);
+                      for (int _i323 = 0; _i323 < _set322.size; ++_i323)
                       {
-                        String _elem292; // optional
-                        _elem292 = iprot.readString();
-                        _val289.add(_elem292);
+                        String _elem324; // required
+                        _elem324 = iprot.readString();
+                        _val321.add(_elem324);
                       }
                       iprot.readSetEnd();
                     }
-                    struct.groups.put(_key28

<TRUNCATED>

Mime
View raw message