Return-Path: X-Original-To: apmail-accumulo-commits-archive@www.apache.org Delivered-To: apmail-accumulo-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 0DC81F8D6 for ; Thu, 2 May 2013 21:50:01 +0000 (UTC) Received: (qmail 76519 invoked by uid 500); 2 May 2013 21:50:01 -0000 Delivered-To: apmail-accumulo-commits-archive@accumulo.apache.org Received: (qmail 76489 invoked by uid 500); 2 May 2013 21:50:00 -0000 Mailing-List: contact commits-help@accumulo.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@accumulo.apache.org Delivered-To: mailing list commits@accumulo.apache.org Received: (qmail 76481 invoked by uid 99); 2 May 2013 21:50:00 -0000 Received: from nike.apache.org (HELO nike.apache.org) (192.87.106.230) by apache.org (qpsmtpd/0.29) with ESMTP; Thu, 02 May 2013 21:50:00 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=5.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Thu, 02 May 2013 21:49:49 +0000 Received: from eris.apache.org (localhost [127.0.0.1]) by eris.apache.org (Postfix) with ESMTP id 8E3F42388A91; Thu, 2 May 2013 21:49:26 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r1478583 [2/3] - in /accumulo/trunk: ./ assemble/ core/ core/src/main/java/org/apache/accumulo/core/client/admin/ core/src/main/java/org/apache/accumulo/core/client/impl/thrift/ core/src/main/java/org/apache/accumulo/core/client/mapreduce/l... Date: Thu, 02 May 2013 21:49:25 -0000 To: commits@accumulo.apache.org From: kturner@apache.org X-Mailer: svnmailer-1.0.8-patched Message-Id: <20130502214926.8E3F42388A91@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Modified: accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/AccumuloProxy.java URL: http://svn.apache.org/viewvc/accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/AccumuloProxy.java?rev=1478583&r1=1478582&r2=1478583&view=diff ============================================================================== --- accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/AccumuloProxy.java (original) +++ accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/AccumuloProxy.java Thu May 2 21:49:24 2013 @@ -78,6 +78,8 @@ import org.slf4j.LoggerFactory; public void flushTable(ByteBuffer login, String tableName, ByteBuffer startRow, ByteBuffer endRow, boolean wait) throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException; + public List getDiskUsage(ByteBuffer login, Set tables) throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException; + public Map> getLocalityGroups(ByteBuffer login, String tableName) throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException; public IteratorSetting getIteratorSetting(ByteBuffer login, String tableName, String iteratorName, IteratorScope scope) throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException; @@ -122,7 +124,7 @@ import org.slf4j.LoggerFactory; public Map tableIdMap(ByteBuffer login) throws org.apache.thrift.TException; - public List getDiskUsage(ByteBuffer login, Set tables) throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException; + public boolean testTableClassLoad(ByteBuffer login, String tableName, String className, String asTypeName) throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException; public void pingTabletServer(ByteBuffer login, String tserver) throws AccumuloException, AccumuloSecurityException, org.apache.thrift.TException; @@ -226,6 +228,8 @@ import org.slf4j.LoggerFactory; public void flushTable(ByteBuffer login, String tableName, ByteBuffer startRow, ByteBuffer endRow, boolean wait, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getDiskUsage(ByteBuffer login, Set tables, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getLocalityGroups(ByteBuffer login, String tableName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; public void getIteratorSetting(ByteBuffer login, String tableName, String iteratorName, IteratorScope scope, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; @@ -270,7 +274,7 @@ import org.slf4j.LoggerFactory; public void tableIdMap(ByteBuffer login, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getDiskUsage(ByteBuffer login, Set tables, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void testTableClassLoad(ByteBuffer login, String tableName, String className, String asTypeName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; public void pingTabletServer(ByteBuffer login, String tserver, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; @@ -804,6 +808,39 @@ import org.slf4j.LoggerFactory; return; } + public List getDiskUsage(ByteBuffer login, Set tables) throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException + { + send_getDiskUsage(login, tables); + return recv_getDiskUsage(); + } + + public void send_getDiskUsage(ByteBuffer login, Set tables) throws org.apache.thrift.TException + { + getDiskUsage_args args = new getDiskUsage_args(); + args.setLogin(login); + args.setTables(tables); + sendBase("getDiskUsage", args); + } + + public List recv_getDiskUsage() throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException + { + getDiskUsage_result result = new getDiskUsage_result(); + receiveBase(result, "getDiskUsage"); + 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, "getDiskUsage failed: unknown result"); + } + public Map> getLocalityGroups(ByteBuffer login, String tableName) throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException { send_getLocalityGroups(login, tableName); @@ -1495,24 +1532,26 @@ import org.slf4j.LoggerFactory; throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "tableIdMap failed: unknown result"); } - public List getDiskUsage(ByteBuffer login, Set tables) throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException + public boolean testTableClassLoad(ByteBuffer login, String tableName, String className, String asTypeName) throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException { - send_getDiskUsage(login, tables); - return recv_getDiskUsage(); + send_testTableClassLoad(login, tableName, className, asTypeName); + return recv_testTableClassLoad(); } - public void send_getDiskUsage(ByteBuffer login, Set tables) throws org.apache.thrift.TException + public void send_testTableClassLoad(ByteBuffer login, String tableName, String className, String asTypeName) throws org.apache.thrift.TException { - getDiskUsage_args args = new getDiskUsage_args(); + testTableClassLoad_args args = new testTableClassLoad_args(); args.setLogin(login); - args.setTables(tables); - sendBase("getDiskUsage", args); + args.setTableName(tableName); + args.setClassName(className); + args.setAsTypeName(asTypeName); + sendBase("testTableClassLoad", args); } - public List recv_getDiskUsage() throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException + public boolean recv_testTableClassLoad() throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException { - getDiskUsage_result result = new getDiskUsage_result(); - receiveBase(result, "getDiskUsage"); + testTableClassLoad_result result = new testTableClassLoad_result(); + receiveBase(result, "testTableClassLoad"); if (result.isSetSuccess()) { return result.success; } @@ -1525,7 +1564,7 @@ import org.slf4j.LoggerFactory; if (result.ouch3 != null) { throw result.ouch3; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getDiskUsage failed: unknown result"); + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "testTableClassLoad failed: unknown result"); } public void pingTabletServer(ByteBuffer login, String tserver) throws AccumuloException, AccumuloSecurityException, org.apache.thrift.TException @@ -3111,6 +3150,41 @@ import org.slf4j.LoggerFactory; } } + public void getDiskUsage(ByteBuffer login, Set tables, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getDiskUsage_call method_call = new getDiskUsage_call(login, tables, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getDiskUsage_call extends org.apache.thrift.async.TAsyncMethodCall { + private ByteBuffer login; + private Set tables; + public getDiskUsage_call(ByteBuffer login, Set tables, org.apache.thrift.async.AsyncMethodCallback 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.tables = tables; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getDiskUsage", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getDiskUsage_args args = new getDiskUsage_args(); + args.setLogin(login); + args.setTables(tables); + args.write(prot); + prot.writeMessageEnd(); + } + + public List 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_getDiskUsage(); + } + } + public void getLocalityGroups(ByteBuffer login, String tableName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { checkReady(); getLocalityGroups_call method_call = new getLocalityGroups_call(login, tableName, resultHandler, this, ___protocolFactory, ___transport); @@ -3947,38 +4021,44 @@ import org.slf4j.LoggerFactory; } } - public void getDiskUsage(ByteBuffer login, Set tables, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void testTableClassLoad(ByteBuffer login, String tableName, String className, String asTypeName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { checkReady(); - getDiskUsage_call method_call = new getDiskUsage_call(login, tables, resultHandler, this, ___protocolFactory, ___transport); + testTableClassLoad_call method_call = new testTableClassLoad_call(login, tableName, className, asTypeName, resultHandler, this, ___protocolFactory, ___transport); this.___currentMethod = method_call; ___manager.call(method_call); } - public static class getDiskUsage_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class testTableClassLoad_call extends org.apache.thrift.async.TAsyncMethodCall { private ByteBuffer login; - private Set tables; - public getDiskUsage_call(ByteBuffer login, Set tables, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + private String tableName; + private String className; + private String asTypeName; + public testTableClassLoad_call(ByteBuffer login, String tableName, String className, String asTypeName, org.apache.thrift.async.AsyncMethodCallback 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.tables = tables; + this.tableName = tableName; + this.className = className; + this.asTypeName = asTypeName; } public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getDiskUsage", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getDiskUsage_args args = new getDiskUsage_args(); + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("testTableClassLoad", org.apache.thrift.protocol.TMessageType.CALL, 0)); + testTableClassLoad_args args = new testTableClassLoad_args(); args.setLogin(login); - args.setTables(tables); + args.setTableName(tableName); + args.setClassName(className); + args.setAsTypeName(asTypeName); args.write(prot); prot.writeMessageEnd(); } - public List getResult() throws AccumuloException, AccumuloSecurityException, TableNotFoundException, org.apache.thrift.TException { + public boolean 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_getDiskUsage(); + return (new Client(prot)).recv_testTableClassLoad(); } } @@ -5260,6 +5340,7 @@ import org.slf4j.LoggerFactory; processMap.put("deleteRows", new deleteRows()); processMap.put("exportTable", new exportTable()); processMap.put("flushTable", new flushTable()); + processMap.put("getDiskUsage", new getDiskUsage()); processMap.put("getLocalityGroups", new getLocalityGroups()); processMap.put("getIteratorSetting", new getIteratorSetting()); processMap.put("getMaxRow", new getMaxRow()); @@ -5282,7 +5363,7 @@ import org.slf4j.LoggerFactory; processMap.put("splitRangeByTablets", new splitRangeByTablets()); processMap.put("tableExists", new tableExists()); processMap.put("tableIdMap", new tableIdMap()); - processMap.put("getDiskUsage", new getDiskUsage()); + processMap.put("testTableClassLoad", new testTableClassLoad()); processMap.put("pingTabletServer", new pingTabletServer()); processMap.put("getActiveScans", new getActiveScans()); processMap.put("getActiveCompactions", new getActiveCompactions()); @@ -5708,6 +5789,34 @@ import org.slf4j.LoggerFactory; } } + public static class getDiskUsage extends org.apache.thrift.ProcessFunction { + public getDiskUsage() { + super("getDiskUsage"); + } + + public getDiskUsage_args getEmptyArgsInstance() { + return new getDiskUsage_args(); + } + + protected boolean isOneway() { + return false; + } + + public getDiskUsage_result getResult(I iface, getDiskUsage_args args) throws org.apache.thrift.TException { + getDiskUsage_result result = new getDiskUsage_result(); + try { + result.success = iface.getDiskUsage(args.login, args.tables); + } catch (AccumuloException ouch1) { + result.ouch1 = ouch1; + } catch (AccumuloSecurityException ouch2) { + result.ouch2 = ouch2; + } catch (TableNotFoundException ouch3) { + result.ouch3 = ouch3; + } + return result; + } + } + public static class getLocalityGroups extends org.apache.thrift.ProcessFunction { public getLocalityGroups() { super("getLocalityGroups"); @@ -6303,23 +6412,24 @@ import org.slf4j.LoggerFactory; } } - public static class getDiskUsage extends org.apache.thrift.ProcessFunction { - public getDiskUsage() { - super("getDiskUsage"); + public static class testTableClassLoad extends org.apache.thrift.ProcessFunction { + public testTableClassLoad() { + super("testTableClassLoad"); } - public getDiskUsage_args getEmptyArgsInstance() { - return new getDiskUsage_args(); + public testTableClassLoad_args getEmptyArgsInstance() { + return new testTableClassLoad_args(); } protected boolean isOneway() { return false; } - public getDiskUsage_result getResult(I iface, getDiskUsage_args args) throws org.apache.thrift.TException { - getDiskUsage_result result = new getDiskUsage_result(); + public testTableClassLoad_result getResult(I iface, testTableClassLoad_args args) throws org.apache.thrift.TException { + testTableClassLoad_result result = new testTableClassLoad_result(); try { - result.success = iface.getDiskUsage(args.login, args.tables); + result.success = iface.testTableClassLoad(args.login, args.tableName, args.className, args.asTypeName); + result.setSuccessIsSet(true); } catch (AccumuloException ouch1) { result.ouch1 = ouch1; } catch (AccumuloSecurityException ouch2) { @@ -24211,13 +24321,1230 @@ import org.slf4j.LoggerFactory; if (struct.isSetOuch1()) { optionals.set(0); } - if (struct.isSetOuch2()) { + if (struct.isSetOuch2()) { + optionals.set(1); + } + if (struct.isSetOuch3()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); + if (struct.isSetOuch1()) { + struct.ouch1.write(oprot); + } + if (struct.isSetOuch2()) { + struct.ouch2.write(oprot); + } + if (struct.isSetOuch3()) { + struct.ouch3.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, flushTable_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(3); + if (incoming.get(0)) { + struct.ouch1 = new AccumuloException(); + struct.ouch1.read(iprot); + struct.setOuch1IsSet(true); + } + if (incoming.get(1)) { + struct.ouch2 = new AccumuloSecurityException(); + struct.ouch2.read(iprot); + struct.setOuch2IsSet(true); + } + if (incoming.get(2)) { + struct.ouch3 = new TableNotFoundException(); + struct.ouch3.read(iprot); + struct.setOuch3IsSet(true); + } + } + } + + } + + public static class getDiskUsage_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getDiskUsage_args"); + + private static final org.apache.thrift.protocol.TField LOGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("login", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField TABLES_FIELD_DESC = new org.apache.thrift.protocol.TField("tables", org.apache.thrift.protocol.TType.SET, (short)2); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new getDiskUsage_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getDiskUsage_argsTupleSchemeFactory()); + } + + public ByteBuffer login; // required + public Set tables; // 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 { + LOGIN((short)1, "login"), + TABLES((short)2, "tables"); + + private static final Map byName = new HashMap(); + + 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: // LOGIN + return LOGIN; + case 2: // TABLES + return TABLES; + 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.LOGIN, new org.apache.thrift.meta_data.FieldMetaData("login", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true))); + tmpMap.put(_Fields.TABLES, new org.apache.thrift.meta_data.FieldMetaData("tables", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.SetMetaData(org.apache.thrift.protocol.TType.SET, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getDiskUsage_args.class, metaDataMap); + } + + public getDiskUsage_args() { + } + + public getDiskUsage_args( + ByteBuffer login, + Set tables) + { + this(); + this.login = login; + this.tables = tables; + } + + /** + * Performs a deep copy on other. + */ + public getDiskUsage_args(getDiskUsage_args other) { + if (other.isSetLogin()) { + this.login = org.apache.thrift.TBaseHelper.copyBinary(other.login); +; + } + if (other.isSetTables()) { + Set __this__tables = new HashSet(); + for (String other_element : other.tables) { + __this__tables.add(other_element); + } + this.tables = __this__tables; + } + } + + public getDiskUsage_args deepCopy() { + return new getDiskUsage_args(this); + } + + @Override + public void clear() { + this.login = null; + this.tables = null; + } + + public byte[] getLogin() { + setLogin(org.apache.thrift.TBaseHelper.rightSize(login)); + return login == null ? null : login.array(); + } + + public ByteBuffer bufferForLogin() { + return login; + } + + public getDiskUsage_args setLogin(byte[] login) { + setLogin(login == null ? (ByteBuffer)null : ByteBuffer.wrap(login)); + return this; + } + + public getDiskUsage_args setLogin(ByteBuffer login) { + this.login = login; + return this; + } + + public void unsetLogin() { + this.login = null; + } + + /** Returns true if field login is set (has been assigned a value) and false otherwise */ + public boolean isSetLogin() { + return this.login != null; + } + + public void setLoginIsSet(boolean value) { + if (!value) { + this.login = null; + } + } + + public int getTablesSize() { + return (this.tables == null) ? 0 : this.tables.size(); + } + + public java.util.Iterator getTablesIterator() { + return (this.tables == null) ? null : this.tables.iterator(); + } + + public void addToTables(String elem) { + if (this.tables == null) { + this.tables = new HashSet(); + } + this.tables.add(elem); + } + + public Set getTables() { + return this.tables; + } + + public getDiskUsage_args setTables(Set tables) { + this.tables = tables; + return this; + } + + public void unsetTables() { + this.tables = null; + } + + /** Returns true if field tables is set (has been assigned a value) and false otherwise */ + public boolean isSetTables() { + return this.tables != null; + } + + public void setTablesIsSet(boolean value) { + if (!value) { + this.tables = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case LOGIN: + if (value == null) { + unsetLogin(); + } else { + setLogin((ByteBuffer)value); + } + break; + + case TABLES: + if (value == null) { + unsetTables(); + } else { + setTables((Set)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case LOGIN: + return getLogin(); + + case TABLES: + return getTables(); + + } + 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 LOGIN: + return isSetLogin(); + case TABLES: + return isSetTables(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getDiskUsage_args) + return this.equals((getDiskUsage_args)that); + return false; + } + + public boolean equals(getDiskUsage_args that) { + if (that == null) + return false; + + boolean this_present_login = true && this.isSetLogin(); + boolean that_present_login = true && that.isSetLogin(); + if (this_present_login || that_present_login) { + if (!(this_present_login && that_present_login)) + return false; + if (!this.login.equals(that.login)) + return false; + } + + boolean this_present_tables = true && this.isSetTables(); + boolean that_present_tables = true && that.isSetTables(); + if (this_present_tables || that_present_tables) { + if (!(this_present_tables && that_present_tables)) + return false; + if (!this.tables.equals(that.tables)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(getDiskUsage_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + getDiskUsage_args typedOther = (getDiskUsage_args)other; + + lastComparison = Boolean.valueOf(isSetLogin()).compareTo(typedOther.isSetLogin()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetLogin()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.login, typedOther.login); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetTables()).compareTo(typedOther.isSetTables()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTables()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tables, typedOther.tables); + 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("getDiskUsage_args("); + boolean first = true; + + sb.append("login:"); + if (this.login == null) { + sb.append("null"); + } else { + org.apache.thrift.TBaseHelper.toString(this.login, sb); + } + first = false; + if (!first) sb.append(", "); + sb.append("tables:"); + if (this.tables == null) { + sb.append("null"); + } else { + sb.append(this.tables); + } + 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 getDiskUsage_argsStandardSchemeFactory implements SchemeFactory { + public getDiskUsage_argsStandardScheme getScheme() { + return new getDiskUsage_argsStandardScheme(); + } + } + + private static class getDiskUsage_argsStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, getDiskUsage_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: // LOGIN + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.login = iprot.readBinary(); + struct.setLoginIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // TABLES + if (schemeField.type == org.apache.thrift.protocol.TType.SET) { + { + org.apache.thrift.protocol.TSet _set182 = iprot.readSetBegin(); + struct.tables = new HashSet(2*_set182.size); + for (int _i183 = 0; _i183 < _set182.size; ++_i183) + { + String _elem184; // required + _elem184 = iprot.readString(); + struct.tables.add(_elem184); + } + iprot.readSetEnd(); + } + struct.setTablesIsSet(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, getDiskUsage_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.login != null) { + oprot.writeFieldBegin(LOGIN_FIELD_DESC); + oprot.writeBinary(struct.login); + oprot.writeFieldEnd(); + } + if (struct.tables != null) { + 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) + { + oprot.writeString(_iter185); + } + oprot.writeSetEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class getDiskUsage_argsTupleSchemeFactory implements SchemeFactory { + public getDiskUsage_argsTupleScheme getScheme() { + return new getDiskUsage_argsTupleScheme(); + } + } + + private static class getDiskUsage_argsTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getDiskUsage_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetLogin()) { + optionals.set(0); + } + if (struct.isSetTables()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetLogin()) { + oprot.writeBinary(struct.login); + } + if (struct.isSetTables()) { + { + oprot.writeI32(struct.tables.size()); + for (String _iter186 : struct.tables) + { + oprot.writeString(_iter186); + } + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getDiskUsage_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.login = iprot.readBinary(); + struct.setLoginIsSet(true); + } + 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(2*_set187.size); + for (int _i188 = 0; _i188 < _set187.size; ++_i188) + { + String _elem189; // required + _elem189 = iprot.readString(); + struct.tables.add(_elem189); + } + } + struct.setTablesIsSet(true); + } + } + } + + } + + public static class getDiskUsage_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getDiskUsage_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 OUCH1_FIELD_DESC = new org.apache.thrift.protocol.TField("ouch1", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final org.apache.thrift.protocol.TField OUCH2_FIELD_DESC = new org.apache.thrift.protocol.TField("ouch2", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final org.apache.thrift.protocol.TField OUCH3_FIELD_DESC = new org.apache.thrift.protocol.TField("ouch3", org.apache.thrift.protocol.TType.STRUCT, (short)3); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new getDiskUsage_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getDiskUsage_resultTupleSchemeFactory()); + } + + public List success; // required + public AccumuloException ouch1; // required + public AccumuloSecurityException ouch2; // required + public TableNotFoundException ouch3; // 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"), + OUCH1((short)1, "ouch1"), + OUCH2((short)2, "ouch2"), + OUCH3((short)3, "ouch3"); + + private static final Map byName = new HashMap(); + + 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: // OUCH1 + return OUCH1; + case 2: // OUCH2 + return OUCH2; + case 3: // OUCH3 + return OUCH3; + 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, DiskUsage.class)))); + tmpMap.put(_Fields.OUCH1, new org.apache.thrift.meta_data.FieldMetaData("ouch1", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.OUCH2, new org.apache.thrift.meta_data.FieldMetaData("ouch2", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.OUCH3, new org.apache.thrift.meta_data.FieldMetaData("ouch3", 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(getDiskUsage_result.class, metaDataMap); + } + + public getDiskUsage_result() { + } + + public getDiskUsage_result( + List success, + AccumuloException ouch1, + AccumuloSecurityException ouch2, + TableNotFoundException ouch3) + { + this(); + this.success = success; + this.ouch1 = ouch1; + this.ouch2 = ouch2; + this.ouch3 = ouch3; + } + + /** + * Performs a deep copy on other. + */ + public getDiskUsage_result(getDiskUsage_result other) { + if (other.isSetSuccess()) { + List __this__success = new ArrayList(); + for (DiskUsage other_element : other.success) { + __this__success.add(new DiskUsage(other_element)); + } + this.success = __this__success; + } + if (other.isSetOuch1()) { + this.ouch1 = new AccumuloException(other.ouch1); + } + if (other.isSetOuch2()) { + this.ouch2 = new AccumuloSecurityException(other.ouch2); + } + if (other.isSetOuch3()) { + this.ouch3 = new TableNotFoundException(other.ouch3); + } + } + + public getDiskUsage_result deepCopy() { + return new getDiskUsage_result(this); + } + + @Override + public void clear() { + this.success = null; + this.ouch1 = null; + this.ouch2 = null; + this.ouch3 = null; + } + + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } + + public java.util.Iterator getSuccessIterator() { + return (this.success == null) ? null : this.success.iterator(); + } + + public void addToSuccess(DiskUsage elem) { + if (this.success == null) { + this.success = new ArrayList(); + } + this.success.add(elem); + } + + public List getSuccess() { + return this.success; + } + + public getDiskUsage_result setSuccess(List 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 AccumuloException getOuch1() { + return this.ouch1; + } + + public getDiskUsage_result setOuch1(AccumuloException ouch1) { + this.ouch1 = ouch1; + return this; + } + + public void unsetOuch1() { + this.ouch1 = null; + } + + /** Returns true if field ouch1 is set (has been assigned a value) and false otherwise */ + public boolean isSetOuch1() { + return this.ouch1 != null; + } + + public void setOuch1IsSet(boolean value) { + if (!value) { + this.ouch1 = null; + } + } + + public AccumuloSecurityException getOuch2() { + return this.ouch2; + } + + public getDiskUsage_result setOuch2(AccumuloSecurityException ouch2) { + this.ouch2 = ouch2; + return this; + } + + public void unsetOuch2() { + this.ouch2 = null; + } + + /** Returns true if field ouch2 is set (has been assigned a value) and false otherwise */ + public boolean isSetOuch2() { + return this.ouch2 != null; + } + + public void setOuch2IsSet(boolean value) { + if (!value) { + this.ouch2 = null; + } + } + + public TableNotFoundException getOuch3() { + return this.ouch3; + } + + public getDiskUsage_result setOuch3(TableNotFoundException ouch3) { + this.ouch3 = ouch3; + return this; + } + + public void unsetOuch3() { + this.ouch3 = null; + } + + /** Returns true if field ouch3 is set (has been assigned a value) and false otherwise */ + public boolean isSetOuch3() { + return this.ouch3 != null; + } + + public void setOuch3IsSet(boolean value) { + if (!value) { + this.ouch3 = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((List)value); + } + break; + + case OUCH1: + if (value == null) { + unsetOuch1(); + } else { + setOuch1((AccumuloException)value); + } + break; + + case OUCH2: + if (value == null) { + unsetOuch2(); + } else { + setOuch2((AccumuloSecurityException)value); + } + break; + + case OUCH3: + if (value == null) { + unsetOuch3(); + } else { + setOuch3((TableNotFoundException)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + case OUCH1: + return getOuch1(); + + case OUCH2: + return getOuch2(); + + case OUCH3: + return getOuch3(); + + } + 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 OUCH1: + return isSetOuch1(); + case OUCH2: + return isSetOuch2(); + case OUCH3: + return isSetOuch3(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getDiskUsage_result) + return this.equals((getDiskUsage_result)that); + return false; + } + + public boolean equals(getDiskUsage_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_ouch1 = true && this.isSetOuch1(); + boolean that_present_ouch1 = true && that.isSetOuch1(); + if (this_present_ouch1 || that_present_ouch1) { + if (!(this_present_ouch1 && that_present_ouch1)) + return false; + if (!this.ouch1.equals(that.ouch1)) + return false; + } + + boolean this_present_ouch2 = true && this.isSetOuch2(); + boolean that_present_ouch2 = true && that.isSetOuch2(); + if (this_present_ouch2 || that_present_ouch2) { + if (!(this_present_ouch2 && that_present_ouch2)) + return false; + if (!this.ouch2.equals(that.ouch2)) + return false; + } + + boolean this_present_ouch3 = true && this.isSetOuch3(); + boolean that_present_ouch3 = true && that.isSetOuch3(); + if (this_present_ouch3 || that_present_ouch3) { + if (!(this_present_ouch3 && that_present_ouch3)) + return false; + if (!this.ouch3.equals(that.ouch3)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(getDiskUsage_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + getDiskUsage_result typedOther = (getDiskUsage_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(isSetOuch1()).compareTo(typedOther.isSetOuch1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOuch1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ouch1, typedOther.ouch1); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetOuch2()).compareTo(typedOther.isSetOuch2()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOuch2()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ouch2, typedOther.ouch2); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetOuch3()).compareTo(typedOther.isSetOuch3()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOuch3()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ouch3, typedOther.ouch3); + 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("getDiskUsage_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("ouch1:"); + if (this.ouch1 == null) { + sb.append("null"); + } else { + sb.append(this.ouch1); + } + first = false; + if (!first) sb.append(", "); + sb.append("ouch2:"); + if (this.ouch2 == null) { + sb.append("null"); + } else { + sb.append(this.ouch2); + } + first = false; + if (!first) sb.append(", "); + sb.append("ouch3:"); + if (this.ouch3 == null) { + sb.append("null"); + } else { + sb.append(this.ouch3); + } + 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 getDiskUsage_resultStandardSchemeFactory implements SchemeFactory { + public getDiskUsage_resultStandardScheme getScheme() { + return new getDiskUsage_resultStandardScheme(); + } + } + + private static class getDiskUsage_resultStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, getDiskUsage_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 _list190 = iprot.readListBegin(); + struct.success = new ArrayList(_list190.size); + for (int _i191 = 0; _i191 < _list190.size; ++_i191) + { + DiskUsage _elem192; // required + _elem192 = new DiskUsage(); + _elem192.read(iprot); + struct.success.add(_elem192); + } + iprot.readListEnd(); + } + struct.setSuccessIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 1: // OUCH1 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.ouch1 = new AccumuloException(); + struct.ouch1.read(iprot); + struct.setOuch1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // OUCH2 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.ouch2 = new AccumuloSecurityException(); + struct.ouch2.read(iprot); + struct.setOuch2IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // OUCH3 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.ouch3 = new TableNotFoundException(); + struct.ouch3.read(iprot); + struct.setOuch3IsSet(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, getDiskUsage_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 (DiskUsage _iter193 : struct.success) + { + _iter193.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + if (struct.ouch1 != null) { + oprot.writeFieldBegin(OUCH1_FIELD_DESC); + struct.ouch1.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.ouch2 != null) { + oprot.writeFieldBegin(OUCH2_FIELD_DESC); + struct.ouch2.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.ouch3 != null) { + oprot.writeFieldBegin(OUCH3_FIELD_DESC); + struct.ouch3.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class getDiskUsage_resultTupleSchemeFactory implements SchemeFactory { + public getDiskUsage_resultTupleScheme getScheme() { + return new getDiskUsage_resultTupleScheme(); + } + } + + private static class getDiskUsage_resultTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getDiskUsage_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + if (struct.isSetOuch1()) { optionals.set(1); } - if (struct.isSetOuch3()) { + if (struct.isSetOuch2()) { optionals.set(2); } - oprot.writeBitSet(optionals, 3); + if (struct.isSetOuch3()) { + optionals.set(3); + } + oprot.writeBitSet(optionals, 4); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (DiskUsage _iter194 : struct.success) + { + _iter194.write(oprot); + } + } + } if (struct.isSetOuch1()) { struct.ouch1.write(oprot); } @@ -24230,20 +25557,34 @@ import org.slf4j.LoggerFactory; } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, flushTable_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, getDiskUsage_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(3); + 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(_list195.size); + for (int _i196 = 0; _i196 < _list195.size; ++_i196) + { + DiskUsage _elem197; // required + _elem197 = new DiskUsage(); + _elem197.read(iprot); + struct.success.add(_elem197); + } + } + struct.setSuccessIsSet(true); + } + if (incoming.get(1)) { struct.ouch1 = new AccumuloException(); struct.ouch1.read(iprot); struct.setOuch1IsSet(true); } - if (incoming.get(1)) { + if (incoming.get(2)) { struct.ouch2 = new AccumuloSecurityException(); struct.ouch2.read(iprot); struct.setOuch2IsSet(true); } - if (incoming.get(2)) { + if (incoming.get(3)) { struct.ouch3 = new TableNotFoundException(); struct.ouch3.read(iprot); struct.setOuch3IsSet(true); @@ -25267,25 +26608,25 @@ import org.slf4j.LoggerFactory; case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map182 = iprot.readMapBegin(); - struct.success = new HashMap>(2*_map182.size); - for (int _i183 = 0; _i183 < _map182.size; ++_i183) + org.apache.thrift.protocol.TMap _map198 = iprot.readMapBegin(); + struct.success = new HashMap>(2*_map198.size); + for (int _i199 = 0; _i199 < _map198.size; ++_i199) { - String _key184; // required - Set _val185; // required - _key184 = iprot.readString(); + String _key200; // required + Set _val201; // required + _key200 = iprot.readString(); { - org.apache.thrift.protocol.TSet _set186 = iprot.readSetBegin(); - _val185 = new HashSet(2*_set186.size); - for (int _i187 = 0; _i187 < _set186.size; ++_i187) + org.apache.thrift.protocol.TSet _set202 = iprot.readSetBegin(); + _val201 = new HashSet(2*_set202.size); + for (int _i203 = 0; _i203 < _set202.size; ++_i203) { - String _elem188; // required - _elem188 = iprot.readString(); - _val185.add(_elem188); + String _elem204; // required + _elem204 = iprot.readString(); + _val201.add(_elem204); } iprot.readSetEnd(); } - struct.success.put(_key184, _val185); + struct.success.put(_key200, _val201); } iprot.readMapEnd(); } @@ -25340,14 +26681,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> _iter189 : struct.success.entrySet()) + for (Map.Entry> _iter205 : struct.success.entrySet()) { - oprot.writeString(_iter189.getKey()); + oprot.writeString(_iter205.getKey()); { - oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, _iter189.getValue().size())); - for (String _iter190 : _iter189.getValue()) + oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, _iter205.getValue().size())); + for (String _iter206 : _iter205.getValue()) { - oprot.writeString(_iter190); + oprot.writeString(_iter206); } oprot.writeSetEnd(); } @@ -25405,14 +26746,14 @@ import org.slf4j.LoggerFactory; if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Map.Entry> _iter191 : struct.success.entrySet()) + for (Map.Entry> _iter207 : struct.success.entrySet()) { - oprot.writeString(_iter191.getKey()); + oprot.writeString(_iter207.getKey()); { - oprot.writeI32(_iter191.getValue().size()); - for (String _iter192 : _iter191.getValue()) + oprot.writeI32(_iter207.getValue().size()); + for (String _iter208 : _iter207.getValue()) { - oprot.writeString(_iter192); + oprot.writeString(_iter208); } } } @@ -25435,24 +26776,24 @@ import org.slf4j.LoggerFactory; BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map193 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.SET, iprot.readI32()); - struct.success = new HashMap>(2*_map193.size); - for (int _i194 = 0; _i194 < _map193.size; ++_i194) + 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>(2*_map209.size); + for (int _i210 = 0; _i210 < _map209.size; ++_i210) { - String _key195; // required - Set _val196; // required - _key195 = iprot.readString(); + String _key211; // required + Set _val212; // required + _key211 = iprot.readString(); { - org.apache.thrift.protocol.TSet _set197 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - _val196 = new HashSet(2*_set197.size); - for (int _i198 = 0; _i198 < _set197.size; ++_i198) + org.apache.thrift.protocol.TSet _set213 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + _val212 = new HashSet(2*_set213.size); + for (int _i214 = 0; _i214 < _set213.size; ++_i214) { - String _elem199; // required - _elem199 = iprot.readString(); - _val196.add(_elem199); + String _elem215; // required + _elem215 = iprot.readString(); + _val212.add(_elem215); } } - struct.success.put(_key195, _val196); + struct.success.put(_key211, _val212); } } struct.setSuccessIsSet(true); @@ -27641,13 +28982,13 @@ import org.slf4j.LoggerFactory; case 3: // AUTHS if (schemeField.type == org.apache.thrift.protocol.TType.SET) { { - org.apache.thrift.protocol.TSet _set200 = iprot.readSetBegin(); - struct.auths = new HashSet(2*_set200.size); - for (int _i201 = 0; _i201 < _set200.size; ++_i201) + org.apache.thrift.protocol.TSet _set216 = iprot.readSetBegin(); + struct.auths = new HashSet(2*_set216.size); + for (int _i217 = 0; _i217 < _set216.size; ++_i217) { - ByteBuffer _elem202; // required - _elem202 = iprot.readBinary(); - struct.auths.add(_elem202); + ByteBuffer _elem218; // required + _elem218 = iprot.readBinary(); + struct.auths.add(_elem218); } iprot.readSetEnd(); } @@ -27717,9 +29058,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 _iter203 : struct.auths) + for (ByteBuffer _iter219 : struct.auths) { - oprot.writeBinary(_iter203); + oprot.writeBinary(_iter219); } oprot.writeSetEnd(); } @@ -27790,9 +29131,9 @@ import org.slf4j.LoggerFactory; if (struct.isSetAuths()) { { oprot.writeI32(struct.auths.size()); - for (ByteBuffer _iter204 : struct.auths) + for (ByteBuffer _iter220 : struct.auths) { - oprot.writeBinary(_iter204); + oprot.writeBinary(_iter220); } } } @@ -27824,13 +29165,13 @@ import org.slf4j.LoggerFactory; } if (incoming.get(2)) { { - org.apache.thrift.protocol.TSet _set205 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.auths = new HashSet(2*_set205.size); - for (int _i206 = 0; _i206 < _set205.size; ++_i206) + org.apache.thrift.protocol.TSet _set221 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.auths = new HashSet(2*_set221.size); + for (int _i222 = 0; _i222 < _set221.size; ++_i222) { - ByteBuffer _elem207; // required - _elem207 = iprot.readBinary(); - struct.auths.add(_elem207); + ByteBuffer _elem223; // required + _elem223 = iprot.readBinary(); + struct.auths.add(_elem223); } } struct.setAuthsIsSet(true); @@ -29537,15 +30878,15 @@ import org.slf4j.LoggerFactory; case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map208 = iprot.readMapBegin(); - struct.success = new HashMap(2*_map208.size); - for (int _i209 = 0; _i209 < _map208.size; ++_i209) + org.apache.thrift.protocol.TMap _map224 = iprot.readMapBegin(); + struct.success = new HashMap(2*_map224.size); + for (int _i225 = 0; _i225 < _map224.size; ++_i225) { - String _key210; // required - String _val211; // required - _key210 = iprot.readString(); - _val211 = iprot.readString(); - struct.success.put(_key210, _val211); + String _key226; // required + String _val227; // required + _key226 = iprot.readString(); + _val227 = iprot.readString(); + struct.success.put(_key226, _val227); } iprot.readMapEnd(); } @@ -29600,10 +30941,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 _iter212 : struct.success.entrySet()) + for (Map.Entry _iter228 : struct.success.entrySet()) { - oprot.writeString(_iter212.getKey()); - oprot.writeString(_iter212.getValue()); + oprot.writeString(_iter228.getKey()); + oprot.writeString(_iter228.getValue()); } oprot.writeMapEnd(); } @@ -29658,10 +30999,10 @@ import org.slf4j.LoggerFactory; if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Map.Entry _iter213 : struct.success.entrySet()) + for (Map.Entry _iter229 : struct.success.entrySet()) { - oprot.writeString(_iter213.getKey()); - oprot.writeString(_iter213.getValue()); + oprot.writeString(_iter229.getKey()); + oprot.writeString(_iter229.getValue()); } } } @@ -29682,15 +31023,15 @@ import org.slf4j.LoggerFactory; BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map214 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new HashMap(2*_map214.size); - for (int _i215 = 0; _i215 < _map214.size; ++_i215) + 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(2*_map230.size); + for (int _i231 = 0; _i231 < _map230.size; ++_i231) { - String _key216; // required - String _val217; // required - _key216 = iprot.readString(); - _val217 = iprot.readString(); - struct.success.put(_key216, _val217); + String _key232; // required + String _val233; // required + _key232 = iprot.readString(); + _val233 = iprot.readString(); + struct.success.put(_key232, _val233); } } struct.setSuccessIsSet(true); @@ -33268,13 +34609,13 @@ import org.slf4j.LoggerFactory; case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list218 = iprot.readListBegin(); - struct.success = new ArrayList(_list218.size); - for (int _i219 = 0; _i219 < _list218.size; ++_i219) + org.apache.thrift.protocol.TList _list234 = iprot.readListBegin(); + struct.success = new ArrayList(_list234.size); + for (int _i235 = 0; _i235 < _list234.size; ++_i235) { - ByteBuffer _elem220; // required - _elem220 = iprot.readBinary(); - struct.success.add(_elem220); + ByteBuffer _elem236; // required + _elem236 = iprot.readBinary(); + struct.success.add(_elem236); } iprot.readListEnd(); } @@ -33329,9 +34670,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 _iter221 : struct.success) + for (ByteBuffer _iter237 : struct.success) { - oprot.writeBinary(_iter221); + oprot.writeBinary(_iter237); } oprot.writeListEnd(); } @@ -33386,9 +34727,9 @@ import org.slf4j.LoggerFactory; if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (ByteBuffer _iter222 : struct.success) + for (ByteBuffer _iter238 : struct.success) { - oprot.writeBinary(_iter222); + oprot.writeBinary(_iter238); } } } @@ -33409,13 +34750,13 @@ import org.slf4j.LoggerFactory; BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list223 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list223.size); - for (int _i224 = 0; _i224 < _list223.size; ++_i224) + org.apache.thrift.protocol.TList _list239 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list239.size); + for (int _i240 = 0; _i240 < _list239.size; ++_i240) { - ByteBuffer _elem225; // required - _elem225 = iprot.readBinary(); - struct.success.add(_elem225); + ByteBuffer _elem241; // required + _elem241 = iprot.readBinary(); + struct.success.add(_elem241); } } struct.setSuccessIsSet(true); @@ -34114,13 +35455,13 @@ import org.slf4j.LoggerFactory; case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.SET) { { - org.apache.thrift.protocol.TSet _set226 = iprot.readSetBegin(); - struct.success = new HashSet(2*_set226.size); - for (int _i227 = 0; _i227 < _set226.size; ++_i227) + org.apache.thrift.protocol.TSet _set242 = iprot.readSetBegin(); + struct.success = new HashSet(2*_set242.size); + for (int _i243 = 0; _i243 < _set242.size; ++_i243) { - String _elem228; // required - _elem228 = iprot.readString(); - struct.success.add(_elem228); + String _elem244; // required + _elem244 = iprot.readString(); + struct.success.add(_elem244); } iprot.readSetEnd(); } @@ -34148,9 +35489,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 _iter229 : struct.success) + for (String _iter245 : struct.success) { - oprot.writeString(_iter229); + oprot.writeString(_iter245); } oprot.writeSetEnd(); } @@ -34181,9 +35522,9 @@ import org.slf4j.LoggerFactory; if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter230 : struct.success) + for (String _iter246 : struct.success) { - oprot.writeString(_iter230); + oprot.writeString(_iter246); } } } @@ -34195,13 +35536,13 @@ import org.slf4j.LoggerFactory; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TSet _set231 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new HashSet(2*_set231.size); - for (int _i232 = 0; _i232 < _set231.size; ++_i232) + org.apache.thrift.protocol.TSet _set247 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new HashSet(2*_set247.size); + for (int _i248 = 0; _i248 < _set247.size; ++_i248) { - String _elem233; // required - _elem233 = iprot.readString(); - struct.success.add(_elem233); + String _elem249; // required + _elem249 = iprot.readString(); + struct.success.add(_elem249); } } struct.setSuccessIsSet(true); @@ -35225,25 +36566,25 @@ import org.slf4j.LoggerFactory; case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map234 = iprot.readMapBegin(); - struct.success = new HashMap>(2*_map234.size); - for (int _i235 = 0; _i235 < _map234.size; ++_i235) + org.apache.thrift.protocol.TMap _map250 = iprot.readMapBegin(); + struct.success = new HashMap>(2*_map250.size); + for (int _i251 = 0; _i251 < _map250.size; ++_i251) { - String _key236; // required - Set _val237; // required - _key236 = iprot.readString(); + String _key252; // required + Set _val253; // required + _key252 = iprot.readString(); { - org.apache.thrift.protocol.TSet _set238 = iprot.readSetBegin(); - _val237 = new HashSet(2*_set238.size); - for (int _i239 = 0; _i239 < _set238.size; ++_i239) + org.apache.thrift.protocol.TSet _set254 = iprot.readSetBegin(); + _val253 = new HashSet(2*_set254.size); + for (int _i255 = 0; _i255 < _set254.size; ++_i255) { - IteratorScope _elem240; // required - _elem240 = IteratorScope.findByValue(iprot.readI32()); - _val237.add(_elem240); + IteratorScope _elem256; // required + _elem256 = IteratorScope.findByValue(iprot.readI32()); + _val253.add(_elem256); } iprot.readSetEnd(); } - struct.success.put(_key236, _val237); + struct.success.put(_key252, _val253); } iprot.readMapEnd(); } @@ -35298,14 +36639,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> _iter241 : struct.success.entrySet()) + for (Map.Entry> _iter257 : struct.success.entrySet()) { - oprot.writeString(_iter241.getKey()); + oprot.writeString(_iter257.getKey()); { - oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, _iter241.getValue().size())); - for (IteratorScope _iter242 : _iter241.getValue()) + oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, _iter257.getValue().size())); + for (IteratorScope _iter258 : _iter257.getValue()) { - oprot.writeI32(_iter242.getValue()); + oprot.writeI32(_iter258.getValue()); } oprot.writeSetEnd(); } @@ -35363,14 +36704,14 @@ import org.slf4j.LoggerFactory; if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Map.Entry> _iter243 : struct.success.entrySet()) + for (Map.Entry> _iter259 : struct.success.entrySet()) { - oprot.writeString(_iter243.getKey()); + oprot.writeString(_iter259.getKey()); { - oprot.writeI32(_iter243.getValue().size()); - for (IteratorScope _iter244 : _iter243.getValue()) + oprot.writeI32(_iter259.getValue().size()); + for (IteratorScope _iter260 : _iter259.getValue()) { - oprot.writeI32(_iter244.getValue()); + oprot.writeI32(_iter260.getValue()); } } } @@ -35393,24 +36734,24 @@ import org.slf4j.LoggerFactory; BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map245 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.SET, iprot.readI32()); - struct.success = new HashMap>(2*_map245.size); - for (int _i246 = 0; _i246 < _map245.size; ++_i246) + 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>(2*_map261.size); + for (int _i262 = 0; _i262 < _map261.size; ++_i262) { - String _key247; // required - Set _val248; // required - _key247 = iprot.readString(); + String _key263; // required + Set _val264; // required + _key263 = iprot.readString(); { - org.apache.thrift.protocol.TSet _set249 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, iprot.readI32()); - _val248 = new HashSet(2*_set249.size); - for (int _i250 = 0; _i250 < _set249.size; ++_i250) + org.apache.thrift.protocol.TSet _set265 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, iprot.readI32()); + _val264 = new HashSet(2*_set265.size); + for (int _i266 = 0; _i266 < _set265.size; ++_i266) { - IteratorScope _elem251; // required - _elem251 = IteratorScope.findByValue(iprot.readI32()); - _val248.add(_elem251); + IteratorScope _elem267; // required + _elem267 = IteratorScope.findByValue(iprot.readI32()); + _val264.add(_elem267); } } - struct.success.put(_key247, _val248); + struct.success.put(_key263, _val264); } } struct.setSuccessIsSet(true); @@ -36445,15 +37786,15 @@ import org.slf4j.LoggerFactory; case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map252 = iprot.readMapBegin(); - struct.success = new HashMap(2*_map252.size); - for (int _i253 = 0; _i253 < _map252.size; ++_i253) + org.apache.thrift.protocol.TMap _map268 = iprot.readMapBegin(); + struct.success = new HashMap(2*_map268.size); + for (int _i269 = 0; _i269 < _map268.size; ++_i269) { - String _key254; // required - int _val255; // required - _key254 = iprot.readString(); - _val255 = iprot.readI32(); - struct.success.put(_key254, _val255); + String _key270; // required + int _val271; // required + _key270 = iprot.readString(); + _val271 = iprot.readI32(); + struct.success.put(_key270, _val271); } iprot.readMapEnd(); } @@ -36508,10 +37849,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 _iter256 : struct.success.entrySet()) + for (Map.Entry _iter272 : struct.success.entrySet()) { - oprot.writeString(_iter256.getKey()); - oprot.writeI32(_iter256.getValue()); + oprot.writeString(_iter272.getKey()); + oprot.writeI32(_iter272.getValue()); } oprot.writeMapEnd(); [... 1405 lines stripped ...]