From 6d0777a551e219c74de4f35c57034fdf30bdf292 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Horv=C3=A1th=20D=C3=B3ra?= <47719724+horvathdora@users.noreply.github.com> Date: Mon, 18 Oct 2021 11:06:32 +0200 Subject: [PATCH] =?UTF-8?q?HBASE-26284=20Add=20HBase=20Thrift=20API=20to?= =?UTF-8?q?=20get=20all=20table=20names=20along=20with=20wh=E2=80=A6=20(#3?= =?UTF-8?q?693)=20(#3745)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Wellington Chevreuil --- .../hadoop/hbase/thrift/DemoClient.java | 64 +- .../thrift/ThriftHBaseServiceHandler.java | 15 + .../hadoop/hbase/thrift/generated/Hbase.java | 3312 +++++++++++------ .../apache/hadoop/hbase/thrift/Hbase.thrift | 8 + .../hadoop/hbase/thrift/TestThriftServer.java | 30 + 5 files changed, 2221 insertions(+), 1208 deletions(-) diff --git a/hbase-examples/src/main/java/org/apache/hadoop/hbase/thrift/DemoClient.java b/hbase-examples/src/main/java/org/apache/hadoop/hbase/thrift/DemoClient.java index c72a1c48490..58075056f38 100644 --- a/hbase-examples/src/main/java/org/apache/hadoop/hbase/thrift/DemoClient.java +++ b/hbase-examples/src/main/java/org/apache/hadoop/hbase/thrift/DemoClient.java @@ -126,7 +126,8 @@ public class DemoClient { TProtocol protocol = new TBinaryProtocol(transport, true, true); Hbase.Client client = new Hbase.Client(protocol); - byte[] t = bytes("demo_table"); + ByteBuffer demoTable = ByteBuffer.wrap(bytes("demo_table")); + ByteBuffer disabledTable = ByteBuffer.wrap(bytes("disabled_table")); // Scan all tables, look for the demo table and delete it. System.out.println("scanning tables..."); @@ -134,7 +135,7 @@ public class DemoClient { for (ByteBuffer name : client.getTableNames()) { System.out.println(" found: " + ClientUtils.utf8(name.array())); - if (ClientUtils.utf8(name.array()).equals(ClientUtils.utf8(t))) { + if (name.equals(demoTable) || name.equals(disabledTable)) { if (client.isTableEnabled(name)) { System.out.println(" disabling table: " + ClientUtils.utf8(name.array())); client.disableTable(name); @@ -158,22 +159,35 @@ public class DemoClient { col.timeToLive = Integer.MAX_VALUE; columns.add(col); - System.out.println("creating table: " + ClientUtils.utf8(t)); + System.out.println("creating table: " + ClientUtils.utf8(demoTable.array())); try { - client.createTable(ByteBuffer.wrap(t), columns); + client.createTable(demoTable, columns); + client.createTable(disabledTable, columns); } catch (AlreadyExists ae) { System.out.println("WARN: " + ae.message); } - System.out.println("column families in " + ClientUtils.utf8(t) + ": "); - Map columnMap = client.getColumnDescriptors(ByteBuffer.wrap(t)); + System.out.println("column families in " + ClientUtils.utf8(demoTable.array()) + ": "); + Map columnMap = client.getColumnDescriptors(demoTable); for (ColumnDescriptor col2 : columnMap.values()) { System.out.println(" column: " + ClientUtils.utf8(col2.name.array()) + ", maxVer: " + col2.maxVersions); } + if (client.isTableEnabled(disabledTable)){ + System.out.println("disabling table: " + ClientUtils.utf8(disabledTable.array())); + client.disableTable(disabledTable); + } + + System.out.println("list tables with enabled statuses : "); + Map statusMap = client.getTableNamesWithIsTableEnabled(); + for (Map.Entry entry : statusMap.entrySet()) { + System.out.println(" Table: " + ClientUtils.utf8(entry.getKey().array()) + + ", is enabled: " + entry.getValue()); + } + Map dummyAttributes = null; boolean writeToWal = false; @@ -190,27 +204,27 @@ public class DemoClient { mutations = new ArrayList<>(1); mutations.add(new Mutation(false, ByteBuffer.wrap(bytes("entry:foo")), ByteBuffer.wrap(invalid), writeToWal)); - client.mutateRow(ByteBuffer.wrap(t), ByteBuffer.wrap(bytes("foo")), + client.mutateRow(demoTable, ByteBuffer.wrap(bytes("foo")), mutations, dummyAttributes); // this row name is valid utf8 mutations = new ArrayList<>(1); mutations.add(new Mutation(false, ByteBuffer.wrap(bytes("entry:foo")), ByteBuffer.wrap(valid), writeToWal)); - client.mutateRow(ByteBuffer.wrap(t), ByteBuffer.wrap(valid), mutations, dummyAttributes); + client.mutateRow(demoTable, ByteBuffer.wrap(valid), mutations, dummyAttributes); // non-utf8 is now allowed in row names because HBase stores values as binary mutations = new ArrayList<>(1); mutations.add(new Mutation(false, ByteBuffer.wrap(bytes("entry:foo")), ByteBuffer.wrap(invalid), writeToWal)); - client.mutateRow(ByteBuffer.wrap(t), ByteBuffer.wrap(invalid), mutations, dummyAttributes); + client.mutateRow(demoTable, ByteBuffer.wrap(invalid), mutations, dummyAttributes); // Run a scanner on the rows we just created ArrayList columnNames = new ArrayList<>(); columnNames.add(ByteBuffer.wrap(bytes("entry:"))); System.out.println("Starting scanner..."); - int scanner = client.scannerOpen(ByteBuffer.wrap(t), ByteBuffer.wrap(bytes("")), columnNames, + int scanner = client.scannerOpen(demoTable, ByteBuffer.wrap(bytes("")), columnNames, dummyAttributes); while (true) { @@ -234,9 +248,9 @@ public class DemoClient { mutations = new ArrayList<>(1); mutations.add(new Mutation(false, ByteBuffer.wrap(bytes("unused:")), ByteBuffer.wrap(bytes("DELETE_ME")), writeToWal)); - client.mutateRow(ByteBuffer.wrap(t), ByteBuffer.wrap(row), mutations, dummyAttributes); - printRow(client.getRow(ByteBuffer.wrap(t), ByteBuffer.wrap(row), dummyAttributes)); - client.deleteAllRow(ByteBuffer.wrap(t), ByteBuffer.wrap(row), dummyAttributes); + client.mutateRow(demoTable, ByteBuffer.wrap(row), mutations, dummyAttributes); + printRow(client.getRow(demoTable, ByteBuffer.wrap(row), dummyAttributes)); + client.deleteAllRow(demoTable, ByteBuffer.wrap(row), dummyAttributes); // sleep to force later timestamp try { @@ -250,8 +264,8 @@ public class DemoClient { ByteBuffer.wrap(bytes("0")), writeToWal)); mutations.add(new Mutation(false, ByteBuffer.wrap(bytes("entry:foo")), ByteBuffer.wrap(bytes("FOO")), writeToWal)); - client.mutateRow(ByteBuffer.wrap(t), ByteBuffer.wrap(row), mutations, dummyAttributes); - printRow(client.getRow(ByteBuffer.wrap(t), ByteBuffer.wrap(row), dummyAttributes)); + client.mutateRow(demoTable, ByteBuffer.wrap(row), mutations, dummyAttributes); + printRow(client.getRow(demoTable, ByteBuffer.wrap(row), dummyAttributes)); Mutation m; mutations = new ArrayList<>(2); @@ -263,16 +277,16 @@ public class DemoClient { m.column = ByteBuffer.wrap(bytes("entry:num")); m.value = ByteBuffer.wrap(bytes("-1")); mutations.add(m); - client.mutateRow(ByteBuffer.wrap(t), ByteBuffer.wrap(row), mutations, dummyAttributes); - printRow(client.getRow(ByteBuffer.wrap(t), ByteBuffer.wrap(row), dummyAttributes)); + client.mutateRow(demoTable, ByteBuffer.wrap(row), mutations, dummyAttributes); + printRow(client.getRow(demoTable, ByteBuffer.wrap(row), dummyAttributes)); mutations = new ArrayList<>(); mutations.add(new Mutation(false, ByteBuffer.wrap(bytes("entry:num")), ByteBuffer.wrap(bytes(Integer.toString(i))), writeToWal)); mutations.add(new Mutation(false, ByteBuffer.wrap(bytes("entry:sqr")), ByteBuffer.wrap(bytes(Integer.toString(i * i))), writeToWal)); - client.mutateRow(ByteBuffer.wrap(t), ByteBuffer.wrap(row), mutations, dummyAttributes); - printRow(client.getRow(ByteBuffer.wrap(t), ByteBuffer.wrap(row), dummyAttributes)); + client.mutateRow(demoTable, ByteBuffer.wrap(row), mutations, dummyAttributes); + printRow(client.getRow(demoTable, ByteBuffer.wrap(row), dummyAttributes)); // sleep to force later timestamp try { @@ -289,11 +303,11 @@ public class DemoClient { m = new Mutation(); m.column = ByteBuffer.wrap(bytes("entry:sqr")); m.isDelete = true; - client.mutateRowTs(ByteBuffer.wrap(t), ByteBuffer.wrap(row), mutations, 1, + client.mutateRowTs(demoTable, ByteBuffer.wrap(row), mutations, 1, dummyAttributes); // shouldn't override latest - printRow(client.getRow(ByteBuffer.wrap(t), ByteBuffer.wrap(row), dummyAttributes)); + printRow(client.getRow(demoTable, ByteBuffer.wrap(row), dummyAttributes)); - List versions = client.getVer(ByteBuffer.wrap(t), ByteBuffer.wrap(row), + List versions = client.getVer(demoTable, ByteBuffer.wrap(row), ByteBuffer.wrap(bytes("entry:num")), 10, dummyAttributes); printVersions(ByteBuffer.wrap(row), versions); @@ -302,7 +316,7 @@ public class DemoClient { System.exit(-1); } - List result = client.get(ByteBuffer.wrap(t), ByteBuffer.wrap(row), + List result = client.get(demoTable, ByteBuffer.wrap(row), ByteBuffer.wrap(bytes("entry:foo")), dummyAttributes); if (!result.isEmpty()) { @@ -316,7 +330,7 @@ public class DemoClient { // scan all rows/columnNames columnNames.clear(); - for (ColumnDescriptor col2 : client.getColumnDescriptors(ByteBuffer.wrap(t)).values()) { + for (ColumnDescriptor col2 : client.getColumnDescriptors(demoTable).values()) { System.out.println("column with name: " + new String(col2.name.array())); System.out.println(col2.toString()); @@ -324,7 +338,7 @@ public class DemoClient { } System.out.println("Starting scanner..."); - scanner = client.scannerOpenWithStop(ByteBuffer.wrap(t), ByteBuffer.wrap(bytes("00020")), + scanner = client.scannerOpenWithStop(demoTable, ByteBuffer.wrap(bytes("00020")), ByteBuffer.wrap(bytes("00040")), columnNames, dummyAttributes); while (true) { diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftHBaseServiceHandler.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftHBaseServiceHandler.java index eae80d031a3..c942977a8e5 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftHBaseServiceHandler.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftHBaseServiceHandler.java @@ -28,6 +28,7 @@ import java.io.IOException; import java.nio.ByteBuffer; import java.util.ArrayList; import java.util.Collections; +import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.TreeMap; @@ -202,6 +203,20 @@ public class ThriftHBaseServiceHandler extends HBaseServiceHandler implements Hb } } + @Override + public Map getTableNamesWithIsTableEnabled() throws IOError { + try { + HashMap tables = new HashMap<>(); + for (ByteBuffer tableName: this.getTableNames()) { + tables.put(tableName, this.isTableEnabled(tableName)); + } + return tables; + } catch (IOError e) { + LOG.warn(e.getMessage(), e); + throw getIOError(e); + } + } + // ThriftServerRunner.compact should be deprecated and replaced with methods specific to // table and region. @Override diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java index 760188cf5dd..75eab8b3453 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java @@ -7,7 +7,7 @@ package org.apache.hadoop.hbase.thrift.generated; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"}) -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-03-24") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-10-12") public class Hbase { public interface Iface { @@ -45,6 +45,13 @@ public class Hbase { */ public java.util.List getTableNames() throws IOError, org.apache.thrift.TException; + /** + * List all the userspace tables and their enabled or disabled flags. + * + * @return list of tables with is enabled flags + */ + public java.util.Map getTableNamesWithIsTableEnabled() throws IOError, org.apache.thrift.TException; + /** * List all the column families assoicated with a table. * @@ -638,6 +645,8 @@ public class Hbase { public void getTableNames(org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws org.apache.thrift.TException; + public void getTableNamesWithIsTableEnabled(org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws org.apache.thrift.TException; + public void getColumnDescriptors(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws org.apache.thrift.TException; public void getTableRegions(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws org.apache.thrift.TException; @@ -881,6 +890,31 @@ public class Hbase { throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getTableNames failed: unknown result"); } + public java.util.Map getTableNamesWithIsTableEnabled() throws IOError, org.apache.thrift.TException + { + send_getTableNamesWithIsTableEnabled(); + return recv_getTableNamesWithIsTableEnabled(); + } + + public void send_getTableNamesWithIsTableEnabled() throws org.apache.thrift.TException + { + getTableNamesWithIsTableEnabled_args args = new getTableNamesWithIsTableEnabled_args(); + sendBase("getTableNamesWithIsTableEnabled", args); + } + + public java.util.Map recv_getTableNamesWithIsTableEnabled() throws IOError, org.apache.thrift.TException + { + getTableNamesWithIsTableEnabled_result result = new getTableNamesWithIsTableEnabled_result(); + receiveBase(result, "getTableNamesWithIsTableEnabled"); + if (result.isSetSuccess()) { + return result.success; + } + if (result.io != null) { + throw result.io; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getTableNamesWithIsTableEnabled failed: unknown result"); + } + public java.util.Map getColumnDescriptors(java.nio.ByteBuffer tableName) throws IOError, org.apache.thrift.TException { send_getColumnDescriptors(tableName); @@ -2183,6 +2217,35 @@ public class Hbase { } } + public void getTableNamesWithIsTableEnabled(org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws org.apache.thrift.TException { + checkReady(); + getTableNamesWithIsTableEnabled_call method_call = new getTableNamesWithIsTableEnabled_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getTableNamesWithIsTableEnabled_call extends org.apache.thrift.async.TAsyncMethodCall> { + public getTableNamesWithIsTableEnabled_call(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); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTableNamesWithIsTableEnabled", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getTableNamesWithIsTableEnabled_args args = new getTableNamesWithIsTableEnabled_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public java.util.Map getResult() throws IOError, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new java.lang.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_getTableNamesWithIsTableEnabled(); + } + } + public void getColumnDescriptors(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws org.apache.thrift.TException { checkReady(); getColumnDescriptors_call method_call = new getColumnDescriptors_call(tableName, resultHandler, this, ___protocolFactory, ___transport); @@ -3720,6 +3783,7 @@ public class Hbase { processMap.put("compact", new compact()); processMap.put("majorCompact", new majorCompact()); processMap.put("getTableNames", new getTableNames()); + processMap.put("getTableNamesWithIsTableEnabled", new getTableNamesWithIsTableEnabled()); processMap.put("getColumnDescriptors", new getColumnDescriptors()); processMap.put("getTableRegions", new getTableRegions()); processMap.put("createTable", new createTable()); @@ -3937,6 +4001,35 @@ public class Hbase { } } + public static class getTableNamesWithIsTableEnabled extends org.apache.thrift.ProcessFunction { + public getTableNamesWithIsTableEnabled() { + super("getTableNamesWithIsTableEnabled"); + } + + public getTableNamesWithIsTableEnabled_args getEmptyArgsInstance() { + return new getTableNamesWithIsTableEnabled_args(); + } + + protected boolean isOneway() { + return false; + } + + @Override + protected boolean rethrowUnhandledExceptions() { + return false; + } + + public getTableNamesWithIsTableEnabled_result getResult(I iface, getTableNamesWithIsTableEnabled_args args) throws org.apache.thrift.TException { + getTableNamesWithIsTableEnabled_result result = new getTableNamesWithIsTableEnabled_result(); + try { + result.success = iface.getTableNamesWithIsTableEnabled(); + } catch (IOError io) { + result.io = io; + } + return result; + } + } + public static class getColumnDescriptors extends org.apache.thrift.ProcessFunction { public getColumnDescriptors() { super("getColumnDescriptors"); @@ -5113,6 +5206,7 @@ public class Hbase { processMap.put("compact", new compact()); processMap.put("majorCompact", new majorCompact()); processMap.put("getTableNames", new getTableNames()); + processMap.put("getTableNamesWithIsTableEnabled", new getTableNamesWithIsTableEnabled()); processMap.put("getColumnDescriptors", new getColumnDescriptors()); processMap.put("getTableRegions", new getTableRegions()); processMap.put("createTable", new createTable()); @@ -5542,6 +5636,71 @@ public class Hbase { } } + public static class getTableNamesWithIsTableEnabled extends org.apache.thrift.AsyncProcessFunction> { + public getTableNamesWithIsTableEnabled() { + super("getTableNamesWithIsTableEnabled"); + } + + public getTableNamesWithIsTableEnabled_args getEmptyArgsInstance() { + return new getTableNamesWithIsTableEnabled_args(); + } + + public org.apache.thrift.async.AsyncMethodCallback> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new org.apache.thrift.async.AsyncMethodCallback>() { + public void onComplete(java.util.Map o) { + getTableNamesWithIsTableEnabled_result result = new getTableNamesWithIsTableEnabled_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + } catch (org.apache.thrift.transport.TTransportException e) { + _LOGGER.error("TTransportException writing to internal frame buffer", e); + fb.close(); + } catch (java.lang.Exception e) { + _LOGGER.error("Exception writing to internal frame buffer", e); + onError(e); + } + } + public void onError(java.lang.Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TSerializable msg; + getTableNamesWithIsTableEnabled_result result = new getTableNamesWithIsTableEnabled_result(); + if (e instanceof IOError) { + result.io = (IOError) e; + result.setIoIsSet(true); + msg = result; + } else if (e instanceof org.apache.thrift.transport.TTransportException) { + _LOGGER.error("TTransportException inside handler", e); + fb.close(); + return; + } else if (e instanceof org.apache.thrift.TApplicationException) { + _LOGGER.error("TApplicationException inside handler", e); + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TApplicationException)e; + } else { + _LOGGER.error("Exception inside handler", e); + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb,msg,msgType,seqid); + } catch (java.lang.Exception ex) { + _LOGGER.error("Exception writing to internal frame buffer", ex); + fb.close(); + } + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getTableNamesWithIsTableEnabled_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws org.apache.thrift.TException { + iface.getTableNamesWithIsTableEnabled(resultHandler); + } + } + public static class getColumnDescriptors extends org.apache.thrift.AsyncProcessFunction> { public getColumnDescriptors() { super("getColumnDescriptors"); @@ -12754,6 +12913,793 @@ public class Hbase { } } + public static class getTableNamesWithIsTableEnabled_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableNamesWithIsTableEnabled_args"); + + + private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableNamesWithIsTableEnabled_argsStandardSchemeFactory(); + private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableNamesWithIsTableEnabled_argsTupleSchemeFactory(); + + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { +; + + private static final java.util.Map byName = new java.util.HashMap(); + + static { + for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + @org.apache.thrift.annotation.Nullable + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + 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 java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + @org.apache.thrift.annotation.Nullable + public static _Fields findByName(java.lang.String name) { + return byName.get(name); + } + + private final short _thriftId; + private final java.lang.String _fieldName; + + _Fields(short thriftId, java.lang.String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public java.lang.String getFieldName() { + return _fieldName; + } + } + public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = java.util.Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableNamesWithIsTableEnabled_args.class, metaDataMap); + } + + public getTableNamesWithIsTableEnabled_args() { + } + + /** + * Performs a deep copy on other. + */ + public getTableNamesWithIsTableEnabled_args(getTableNamesWithIsTableEnabled_args other) { + } + + public getTableNamesWithIsTableEnabled_args deepCopy() { + return new getTableNamesWithIsTableEnabled_args(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) { + switch (field) { + } + } + + @org.apache.thrift.annotation.Nullable + public java.lang.Object getFieldValue(_Fields field) { + switch (field) { + } + throw new java.lang.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 java.lang.IllegalArgumentException(); + } + + switch (field) { + } + throw new java.lang.IllegalStateException(); + } + + @Override + public boolean equals(java.lang.Object that) { + if (that instanceof getTableNamesWithIsTableEnabled_args) + return this.equals((getTableNamesWithIsTableEnabled_args)that); + return false; + } + + public boolean equals(getTableNamesWithIsTableEnabled_args that) { + if (that == null) + return false; + if (this == that) + return true; + + return true; + } + + @Override + public int hashCode() { + int hashCode = 1; + + return hashCode; + } + + @Override + public int compareTo(getTableNamesWithIsTableEnabled_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + return 0; + } + + @org.apache.thrift.annotation.Nullable + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + scheme(iprot).read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + scheme(oprot).write(oprot, this); + } + + @Override + public java.lang.String toString() { + java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableNamesWithIsTableEnabled_args("); + boolean first = true; + + 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, java.lang.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 getTableNamesWithIsTableEnabled_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory { + public getTableNamesWithIsTableEnabled_argsStandardScheme getScheme() { + return new getTableNamesWithIsTableEnabled_argsStandardScheme(); + } + } + + private static class getTableNamesWithIsTableEnabled_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, getTableNamesWithIsTableEnabled_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) { + 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, getTableNamesWithIsTableEnabled_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class getTableNamesWithIsTableEnabled_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory { + public getTableNamesWithIsTableEnabled_argsTupleScheme getScheme() { + return new getTableNamesWithIsTableEnabled_argsTupleScheme(); + } + } + + private static class getTableNamesWithIsTableEnabled_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getTableNamesWithIsTableEnabled_args struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getTableNamesWithIsTableEnabled_args struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot; + } + } + + private static S scheme(org.apache.thrift.protocol.TProtocol proto) { + return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme(); + } + } + + public static class getTableNamesWithIsTableEnabled_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableNamesWithIsTableEnabled_result"); + + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.MAP, (short)0); + private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableNamesWithIsTableEnabled_resultStandardSchemeFactory(); + private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableNamesWithIsTableEnabled_resultTupleSchemeFactory(); + + public @org.apache.thrift.annotation.Nullable java.util.Map success; // required + public @org.apache.thrift.annotation.Nullable IOError io; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + SUCCESS((short)0, "success"), + IO((short)1, "io"); + + private static final java.util.Map byName = new java.util.HashMap(); + + static { + for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + @org.apache.thrift.annotation.Nullable + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 0: // SUCCESS + return SUCCESS; + case 1: // IO + return IO; + 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 java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + @org.apache.thrift.annotation.Nullable + public static _Fields findByName(java.lang.String name) { + return byName.get(name); + } + + private final short _thriftId; + private final java.lang.String _fieldName; + + _Fields(short thriftId, java.lang.String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public java.lang.String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.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.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"), + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)))); + tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class))); + metaDataMap = java.util.Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableNamesWithIsTableEnabled_result.class, metaDataMap); + } + + public getTableNamesWithIsTableEnabled_result() { + } + + public getTableNamesWithIsTableEnabled_result( + java.util.Map success, + IOError io) + { + this(); + this.success = success; + this.io = io; + } + + /** + * Performs a deep copy on other. + */ + public getTableNamesWithIsTableEnabled_result(getTableNamesWithIsTableEnabled_result other) { + if (other.isSetSuccess()) { + java.util.Map __this__success = new java.util.HashMap(other.success.size()); + for (java.util.Map.Entry other_element : other.success.entrySet()) { + + java.nio.ByteBuffer other_element_key = other_element.getKey(); + java.lang.Boolean other_element_value = other_element.getValue(); + + java.nio.ByteBuffer __this__success_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key); + + java.lang.Boolean __this__success_copy_value = other_element_value; + + __this__success.put(__this__success_copy_key, __this__success_copy_value); + } + this.success = __this__success; + } + if (other.isSetIo()) { + this.io = new IOError(other.io); + } + } + + public getTableNamesWithIsTableEnabled_result deepCopy() { + return new getTableNamesWithIsTableEnabled_result(this); + } + + @Override + public void clear() { + this.success = null; + this.io = null; + } + + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } + + public void putToSuccess(java.nio.ByteBuffer key, boolean val) { + if (this.success == null) { + this.success = new java.util.HashMap(); + } + this.success.put(key, val); + } + + @org.apache.thrift.annotation.Nullable + public java.util.Map getSuccess() { + return this.success; + } + + public getTableNamesWithIsTableEnabled_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.Map 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; + } + } + + @org.apache.thrift.annotation.Nullable + public IOError getIo() { + return this.io; + } + + public getTableNamesWithIsTableEnabled_result setIo(@org.apache.thrift.annotation.Nullable IOError io) { + this.io = io; + return this; + } + + public void unsetIo() { + this.io = null; + } + + /** Returns true if field io is set (has been assigned a value) and false otherwise */ + public boolean isSetIo() { + return this.io != null; + } + + public void setIoIsSet(boolean value) { + if (!value) { + this.io = null; + } + } + + public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((java.util.Map)value); + } + break; + + case IO: + if (value == null) { + unsetIo(); + } else { + setIo((IOError)value); + } + break; + + } + } + + @org.apache.thrift.annotation.Nullable + public java.lang.Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + case IO: + return getIo(); + + } + throw new java.lang.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 java.lang.IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + case IO: + return isSetIo(); + } + throw new java.lang.IllegalStateException(); + } + + @Override + public boolean equals(java.lang.Object that) { + if (that instanceof getTableNamesWithIsTableEnabled_result) + return this.equals((getTableNamesWithIsTableEnabled_result)that); + return false; + } + + public boolean equals(getTableNamesWithIsTableEnabled_result that) { + if (that == null) + return false; + if (this == that) + return true; + + 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_io = true && this.isSetIo(); + boolean that_present_io = true && that.isSetIo(); + if (this_present_io || that_present_io) { + if (!(this_present_io && that_present_io)) + return false; + if (!this.io.equals(that.io)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + int hashCode = 1; + + hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287); + if (isSetSuccess()) + hashCode = hashCode * 8191 + success.hashCode(); + + hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287); + if (isSetIo()) + hashCode = hashCode * 8191 + io.hashCode(); + + return hashCode; + } + + @Override + public int compareTo(getTableNamesWithIsTableEnabled_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSuccess()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetIo()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + @org.apache.thrift.annotation.Nullable + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + scheme(iprot).read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + scheme(oprot).write(oprot, this); + } + + @Override + public java.lang.String toString() { + java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableNamesWithIsTableEnabled_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("io:"); + if (this.io == null) { + sb.append("null"); + } else { + sb.append(this.io); + } + 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, java.lang.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 getTableNamesWithIsTableEnabled_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory { + public getTableNamesWithIsTableEnabled_resultStandardScheme getScheme() { + return new getTableNamesWithIsTableEnabled_resultStandardScheme(); + } + } + + private static class getTableNamesWithIsTableEnabled_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, getTableNamesWithIsTableEnabled_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.MAP) { + { + org.apache.thrift.protocol.TMap _map58 = iprot.readMapBegin(); + struct.success = new java.util.HashMap(2*_map58.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key59; + boolean _val60; + for (int _i61 = 0; _i61 < _map58.size; ++_i61) + { + _key59 = iprot.readBinary(); + _val60 = iprot.readBool(); + struct.success.put(_key59, _val60); + } + iprot.readMapEnd(); + } + struct.setSuccessIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 1: // IO + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.io = new IOError(); + struct.io.read(iprot); + struct.setIoIsSet(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, getTableNamesWithIsTableEnabled_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.success != null) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + { + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.BOOL, struct.success.size())); + for (java.util.Map.Entry _iter62 : struct.success.entrySet()) + { + oprot.writeBinary(_iter62.getKey()); + oprot.writeBool(_iter62.getValue()); + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + if (struct.io != null) { + oprot.writeFieldBegin(IO_FIELD_DESC); + struct.io.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class getTableNamesWithIsTableEnabled_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory { + public getTableNamesWithIsTableEnabled_resultTupleScheme getScheme() { + return new getTableNamesWithIsTableEnabled_resultTupleScheme(); + } + } + + private static class getTableNamesWithIsTableEnabled_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getTableNamesWithIsTableEnabled_result struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot; + java.util.BitSet optionals = new java.util.BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + if (struct.isSetIo()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (java.util.Map.Entry _iter63 : struct.success.entrySet()) + { + oprot.writeBinary(_iter63.getKey()); + oprot.writeBool(_iter63.getValue()); + } + } + } + if (struct.isSetIo()) { + struct.io.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getTableNamesWithIsTableEnabled_result struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot; + java.util.BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TMap _map64 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.BOOL); + struct.success = new java.util.HashMap(2*_map64.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key65; + boolean _val66; + for (int _i67 = 0; _i67 < _map64.size; ++_i67) + { + _key65 = iprot.readBinary(); + _val66 = iprot.readBool(); + struct.success.put(_key65, _val66); + } + } + struct.setSuccessIsSet(true); + } + if (incoming.get(1)) { + struct.io = new IOError(); + struct.io.read(iprot); + struct.setIoIsSet(true); + } + } + } + + private static S scheme(org.apache.thrift.protocol.TProtocol proto) { + return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme(); + } + } + public static class getColumnDescriptors_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getColumnDescriptors_args"); @@ -13548,16 +14494,16 @@ public class Hbase { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map58 = iprot.readMapBegin(); - struct.success = new java.util.HashMap(2*_map58.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key59; - @org.apache.thrift.annotation.Nullable ColumnDescriptor _val60; - for (int _i61 = 0; _i61 < _map58.size; ++_i61) + org.apache.thrift.protocol.TMap _map68 = iprot.readMapBegin(); + struct.success = new java.util.HashMap(2*_map68.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key69; + @org.apache.thrift.annotation.Nullable ColumnDescriptor _val70; + for (int _i71 = 0; _i71 < _map68.size; ++_i71) { - _key59 = iprot.readBinary(); - _val60 = new ColumnDescriptor(); - _val60.read(iprot); - struct.success.put(_key59, _val60); + _key69 = iprot.readBinary(); + _val70 = new ColumnDescriptor(); + _val70.read(iprot); + struct.success.put(_key69, _val70); } iprot.readMapEnd(); } @@ -13594,10 +14540,10 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (java.util.Map.Entry _iter62 : struct.success.entrySet()) + for (java.util.Map.Entry _iter72 : struct.success.entrySet()) { - oprot.writeBinary(_iter62.getKey()); - _iter62.getValue().write(oprot); + oprot.writeBinary(_iter72.getKey()); + _iter72.getValue().write(oprot); } oprot.writeMapEnd(); } @@ -13636,10 +14582,10 @@ public class Hbase { if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.util.Map.Entry _iter63 : struct.success.entrySet()) + for (java.util.Map.Entry _iter73 : struct.success.entrySet()) { - oprot.writeBinary(_iter63.getKey()); - _iter63.getValue().write(oprot); + oprot.writeBinary(_iter73.getKey()); + _iter73.getValue().write(oprot); } } } @@ -13654,16 +14600,16 @@ public class Hbase { java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map64 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.HashMap(2*_map64.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key65; - @org.apache.thrift.annotation.Nullable ColumnDescriptor _val66; - for (int _i67 = 0; _i67 < _map64.size; ++_i67) + org.apache.thrift.protocol.TMap _map74 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.HashMap(2*_map74.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key75; + @org.apache.thrift.annotation.Nullable ColumnDescriptor _val76; + for (int _i77 = 0; _i77 < _map74.size; ++_i77) { - _key65 = iprot.readBinary(); - _val66 = new ColumnDescriptor(); - _val66.read(iprot); - struct.success.put(_key65, _val66); + _key75 = iprot.readBinary(); + _val76 = new ColumnDescriptor(); + _val76.read(iprot); + struct.success.put(_key75, _val76); } } struct.setSuccessIsSet(true); @@ -14471,14 +15417,14 @@ public class Hbase { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list68 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list68.size); - @org.apache.thrift.annotation.Nullable TRegionInfo _elem69; - for (int _i70 = 0; _i70 < _list68.size; ++_i70) + org.apache.thrift.protocol.TList _list78 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list78.size); + @org.apache.thrift.annotation.Nullable TRegionInfo _elem79; + for (int _i80 = 0; _i80 < _list78.size; ++_i80) { - _elem69 = new TRegionInfo(); - _elem69.read(iprot); - struct.success.add(_elem69); + _elem79 = new TRegionInfo(); + _elem79.read(iprot); + struct.success.add(_elem79); } iprot.readListEnd(); } @@ -14515,9 +15461,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TRegionInfo _iter71 : struct.success) + for (TRegionInfo _iter81 : struct.success) { - _iter71.write(oprot); + _iter81.write(oprot); } oprot.writeListEnd(); } @@ -14556,9 +15502,9 @@ public class Hbase { if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TRegionInfo _iter72 : struct.success) + for (TRegionInfo _iter82 : struct.success) { - _iter72.write(oprot); + _iter82.write(oprot); } } } @@ -14573,14 +15519,14 @@ public class Hbase { java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list73 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list73.size); - @org.apache.thrift.annotation.Nullable TRegionInfo _elem74; - for (int _i75 = 0; _i75 < _list73.size; ++_i75) + org.apache.thrift.protocol.TList _list83 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list83.size); + @org.apache.thrift.annotation.Nullable TRegionInfo _elem84; + for (int _i85 = 0; _i85 < _list83.size; ++_i85) { - _elem74 = new TRegionInfo(); - _elem74.read(iprot); - struct.success.add(_elem74); + _elem84 = new TRegionInfo(); + _elem84.read(iprot); + struct.success.add(_elem84); } } struct.setSuccessIsSet(true); @@ -15043,14 +15989,14 @@ public class Hbase { case 2: // COLUMN_FAMILIES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list76 = iprot.readListBegin(); - struct.columnFamilies = new java.util.ArrayList(_list76.size); - @org.apache.thrift.annotation.Nullable ColumnDescriptor _elem77; - for (int _i78 = 0; _i78 < _list76.size; ++_i78) + org.apache.thrift.protocol.TList _list86 = iprot.readListBegin(); + struct.columnFamilies = new java.util.ArrayList(_list86.size); + @org.apache.thrift.annotation.Nullable ColumnDescriptor _elem87; + for (int _i88 = 0; _i88 < _list86.size; ++_i88) { - _elem77 = new ColumnDescriptor(); - _elem77.read(iprot); - struct.columnFamilies.add(_elem77); + _elem87 = new ColumnDescriptor(); + _elem87.read(iprot); + struct.columnFamilies.add(_elem87); } iprot.readListEnd(); } @@ -15083,9 +16029,9 @@ public class Hbase { oprot.writeFieldBegin(COLUMN_FAMILIES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.columnFamilies.size())); - for (ColumnDescriptor _iter79 : struct.columnFamilies) + for (ColumnDescriptor _iter89 : struct.columnFamilies) { - _iter79.write(oprot); + _iter89.write(oprot); } oprot.writeListEnd(); } @@ -15122,9 +16068,9 @@ public class Hbase { if (struct.isSetColumnFamilies()) { { oprot.writeI32(struct.columnFamilies.size()); - for (ColumnDescriptor _iter80 : struct.columnFamilies) + for (ColumnDescriptor _iter90 : struct.columnFamilies) { - _iter80.write(oprot); + _iter90.write(oprot); } } } @@ -15140,14 +16086,14 @@ public class Hbase { } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list81 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.columnFamilies = new java.util.ArrayList(_list81.size); - @org.apache.thrift.annotation.Nullable ColumnDescriptor _elem82; - for (int _i83 = 0; _i83 < _list81.size; ++_i83) + org.apache.thrift.protocol.TList _list91 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.columnFamilies = new java.util.ArrayList(_list91.size); + @org.apache.thrift.annotation.Nullable ColumnDescriptor _elem92; + for (int _i93 = 0; _i93 < _list91.size; ++_i93) { - _elem82 = new ColumnDescriptor(); - _elem82.read(iprot); - struct.columnFamilies.add(_elem82); + _elem92 = new ColumnDescriptor(); + _elem92.read(iprot); + struct.columnFamilies.add(_elem92); } } struct.setColumnFamiliesIsSet(true); @@ -17177,15 +18123,15 @@ public class Hbase { case 4: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map84 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map84.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key85; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val86; - for (int _i87 = 0; _i87 < _map84.size; ++_i87) + org.apache.thrift.protocol.TMap _map94 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map94.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key95; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val96; + for (int _i97 = 0; _i97 < _map94.size; ++_i97) { - _key85 = iprot.readBinary(); - _val86 = iprot.readBinary(); - struct.attributes.put(_key85, _val86); + _key95 = iprot.readBinary(); + _val96 = iprot.readBinary(); + struct.attributes.put(_key95, _val96); } iprot.readMapEnd(); } @@ -17228,10 +18174,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter88 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter98 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter88.getKey()); - oprot.writeBinary(_iter88.getValue()); + oprot.writeBinary(_iter98.getKey()); + oprot.writeBinary(_iter98.getValue()); } oprot.writeMapEnd(); } @@ -17280,10 +18226,10 @@ public class Hbase { if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter89 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter99 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter89.getKey()); - oprot.writeBinary(_iter89.getValue()); + oprot.writeBinary(_iter99.getKey()); + oprot.writeBinary(_iter99.getValue()); } } } @@ -17307,15 +18253,15 @@ public class Hbase { } if (incoming.get(3)) { { - org.apache.thrift.protocol.TMap _map90 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map90.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key91; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val92; - for (int _i93 = 0; _i93 < _map90.size; ++_i93) + org.apache.thrift.protocol.TMap _map100 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map100.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key101; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val102; + for (int _i103 = 0; _i103 < _map100.size; ++_i103) { - _key91 = iprot.readBinary(); - _val92 = iprot.readBinary(); - struct.attributes.put(_key91, _val92); + _key101 = iprot.readBinary(); + _val102 = iprot.readBinary(); + struct.attributes.put(_key101, _val102); } } struct.setAttributesIsSet(true); @@ -17728,14 +18674,14 @@ public class Hbase { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list94 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list94.size); - @org.apache.thrift.annotation.Nullable TCell _elem95; - for (int _i96 = 0; _i96 < _list94.size; ++_i96) + org.apache.thrift.protocol.TList _list104 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list104.size); + @org.apache.thrift.annotation.Nullable TCell _elem105; + for (int _i106 = 0; _i106 < _list104.size; ++_i106) { - _elem95 = new TCell(); - _elem95.read(iprot); - struct.success.add(_elem95); + _elem105 = new TCell(); + _elem105.read(iprot); + struct.success.add(_elem105); } iprot.readListEnd(); } @@ -17772,9 +18718,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TCell _iter97 : struct.success) + for (TCell _iter107 : struct.success) { - _iter97.write(oprot); + _iter107.write(oprot); } oprot.writeListEnd(); } @@ -17813,9 +18759,9 @@ public class Hbase { if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TCell _iter98 : struct.success) + for (TCell _iter108 : struct.success) { - _iter98.write(oprot); + _iter108.write(oprot); } } } @@ -17830,14 +18776,14 @@ public class Hbase { java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list99 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list99.size); - @org.apache.thrift.annotation.Nullable TCell _elem100; - for (int _i101 = 0; _i101 < _list99.size; ++_i101) + org.apache.thrift.protocol.TList _list109 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list109.size); + @org.apache.thrift.annotation.Nullable TCell _elem110; + for (int _i111 = 0; _i111 < _list109.size; ++_i111) { - _elem100 = new TCell(); - _elem100.read(iprot); - struct.success.add(_elem100); + _elem110 = new TCell(); + _elem110.read(iprot); + struct.success.add(_elem110); } } struct.setSuccessIsSet(true); @@ -18633,15 +19579,15 @@ public class Hbase { case 5: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map102 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map102.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key103; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val104; - for (int _i105 = 0; _i105 < _map102.size; ++_i105) + org.apache.thrift.protocol.TMap _map112 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map112.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key113; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val114; + for (int _i115 = 0; _i115 < _map112.size; ++_i115) { - _key103 = iprot.readBinary(); - _val104 = iprot.readBinary(); - struct.attributes.put(_key103, _val104); + _key113 = iprot.readBinary(); + _val114 = iprot.readBinary(); + struct.attributes.put(_key113, _val114); } iprot.readMapEnd(); } @@ -18687,10 +19633,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter106 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter116 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter106.getKey()); - oprot.writeBinary(_iter106.getValue()); + oprot.writeBinary(_iter116.getKey()); + oprot.writeBinary(_iter116.getValue()); } oprot.writeMapEnd(); } @@ -18745,10 +19691,10 @@ public class Hbase { if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter107 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter117 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter107.getKey()); - oprot.writeBinary(_iter107.getValue()); + oprot.writeBinary(_iter117.getKey()); + oprot.writeBinary(_iter117.getValue()); } } } @@ -18776,15 +19722,15 @@ public class Hbase { } if (incoming.get(4)) { { - org.apache.thrift.protocol.TMap _map108 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map108.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key109; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val110; - for (int _i111 = 0; _i111 < _map108.size; ++_i111) + org.apache.thrift.protocol.TMap _map118 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map118.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key119; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val120; + for (int _i121 = 0; _i121 < _map118.size; ++_i121) { - _key109 = iprot.readBinary(); - _val110 = iprot.readBinary(); - struct.attributes.put(_key109, _val110); + _key119 = iprot.readBinary(); + _val120 = iprot.readBinary(); + struct.attributes.put(_key119, _val120); } } struct.setAttributesIsSet(true); @@ -19197,14 +20143,14 @@ public class Hbase { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list112 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list112.size); - @org.apache.thrift.annotation.Nullable TCell _elem113; - for (int _i114 = 0; _i114 < _list112.size; ++_i114) + org.apache.thrift.protocol.TList _list122 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list122.size); + @org.apache.thrift.annotation.Nullable TCell _elem123; + for (int _i124 = 0; _i124 < _list122.size; ++_i124) { - _elem113 = new TCell(); - _elem113.read(iprot); - struct.success.add(_elem113); + _elem123 = new TCell(); + _elem123.read(iprot); + struct.success.add(_elem123); } iprot.readListEnd(); } @@ -19241,9 +20187,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TCell _iter115 : struct.success) + for (TCell _iter125 : struct.success) { - _iter115.write(oprot); + _iter125.write(oprot); } oprot.writeListEnd(); } @@ -19282,9 +20228,9 @@ public class Hbase { if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TCell _iter116 : struct.success) + for (TCell _iter126 : struct.success) { - _iter116.write(oprot); + _iter126.write(oprot); } } } @@ -19299,14 +20245,14 @@ public class Hbase { java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list117 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list117.size); - @org.apache.thrift.annotation.Nullable TCell _elem118; - for (int _i119 = 0; _i119 < _list117.size; ++_i119) + org.apache.thrift.protocol.TList _list127 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list127.size); + @org.apache.thrift.annotation.Nullable TCell _elem128; + for (int _i129 = 0; _i129 < _list127.size; ++_i129) { - _elem118 = new TCell(); - _elem118.read(iprot); - struct.success.add(_elem118); + _elem128 = new TCell(); + _elem128.read(iprot); + struct.success.add(_elem128); } } struct.setSuccessIsSet(true); @@ -20197,15 +21143,15 @@ public class Hbase { case 6: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map120 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map120.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key121; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val122; - for (int _i123 = 0; _i123 < _map120.size; ++_i123) + org.apache.thrift.protocol.TMap _map130 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map130.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key131; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val132; + for (int _i133 = 0; _i133 < _map130.size; ++_i133) { - _key121 = iprot.readBinary(); - _val122 = iprot.readBinary(); - struct.attributes.put(_key121, _val122); + _key131 = iprot.readBinary(); + _val132 = iprot.readBinary(); + struct.attributes.put(_key131, _val132); } iprot.readMapEnd(); } @@ -20254,10 +21200,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter124 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter134 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter124.getKey()); - oprot.writeBinary(_iter124.getValue()); + oprot.writeBinary(_iter134.getKey()); + oprot.writeBinary(_iter134.getValue()); } oprot.writeMapEnd(); } @@ -20318,10 +21264,10 @@ public class Hbase { if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter125 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter135 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter125.getKey()); - oprot.writeBinary(_iter125.getValue()); + oprot.writeBinary(_iter135.getKey()); + oprot.writeBinary(_iter135.getValue()); } } } @@ -20353,15 +21299,15 @@ public class Hbase { } if (incoming.get(5)) { { - org.apache.thrift.protocol.TMap _map126 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map126.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key127; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val128; - for (int _i129 = 0; _i129 < _map126.size; ++_i129) + org.apache.thrift.protocol.TMap _map136 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map136.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key137; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val138; + for (int _i139 = 0; _i139 < _map136.size; ++_i139) { - _key127 = iprot.readBinary(); - _val128 = iprot.readBinary(); - struct.attributes.put(_key127, _val128); + _key137 = iprot.readBinary(); + _val138 = iprot.readBinary(); + struct.attributes.put(_key137, _val138); } } struct.setAttributesIsSet(true); @@ -20774,14 +21720,14 @@ public class Hbase { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list130 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list130.size); - @org.apache.thrift.annotation.Nullable TCell _elem131; - for (int _i132 = 0; _i132 < _list130.size; ++_i132) + org.apache.thrift.protocol.TList _list140 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list140.size); + @org.apache.thrift.annotation.Nullable TCell _elem141; + for (int _i142 = 0; _i142 < _list140.size; ++_i142) { - _elem131 = new TCell(); - _elem131.read(iprot); - struct.success.add(_elem131); + _elem141 = new TCell(); + _elem141.read(iprot); + struct.success.add(_elem141); } iprot.readListEnd(); } @@ -20818,9 +21764,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TCell _iter133 : struct.success) + for (TCell _iter143 : struct.success) { - _iter133.write(oprot); + _iter143.write(oprot); } oprot.writeListEnd(); } @@ -20859,9 +21805,9 @@ public class Hbase { if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TCell _iter134 : struct.success) + for (TCell _iter144 : struct.success) { - _iter134.write(oprot); + _iter144.write(oprot); } } } @@ -20876,14 +21822,14 @@ public class Hbase { java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list135 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list135.size); - @org.apache.thrift.annotation.Nullable TCell _elem136; - for (int _i137 = 0; _i137 < _list135.size; ++_i137) + org.apache.thrift.protocol.TList _list145 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list145.size); + @org.apache.thrift.annotation.Nullable TCell _elem146; + for (int _i147 = 0; _i147 < _list145.size; ++_i147) { - _elem136 = new TCell(); - _elem136.read(iprot); - struct.success.add(_elem136); + _elem146 = new TCell(); + _elem146.read(iprot); + struct.success.add(_elem146); } } struct.setSuccessIsSet(true); @@ -21465,15 +22411,15 @@ public class Hbase { case 3: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map138 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map138.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key139; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val140; - for (int _i141 = 0; _i141 < _map138.size; ++_i141) + org.apache.thrift.protocol.TMap _map148 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map148.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key149; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val150; + for (int _i151 = 0; _i151 < _map148.size; ++_i151) { - _key139 = iprot.readBinary(); - _val140 = iprot.readBinary(); - struct.attributes.put(_key139, _val140); + _key149 = iprot.readBinary(); + _val150 = iprot.readBinary(); + struct.attributes.put(_key149, _val150); } iprot.readMapEnd(); } @@ -21511,10 +22457,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter142 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter152 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter142.getKey()); - oprot.writeBinary(_iter142.getValue()); + oprot.writeBinary(_iter152.getKey()); + oprot.writeBinary(_iter152.getValue()); } oprot.writeMapEnd(); } @@ -21557,10 +22503,10 @@ public class Hbase { if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter143 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter153 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter143.getKey()); - oprot.writeBinary(_iter143.getValue()); + oprot.writeBinary(_iter153.getKey()); + oprot.writeBinary(_iter153.getValue()); } } } @@ -21580,15 +22526,15 @@ public class Hbase { } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map144 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map144.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key145; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val146; - for (int _i147 = 0; _i147 < _map144.size; ++_i147) + org.apache.thrift.protocol.TMap _map154 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map154.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key155; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val156; + for (int _i157 = 0; _i157 < _map154.size; ++_i157) { - _key145 = iprot.readBinary(); - _val146 = iprot.readBinary(); - struct.attributes.put(_key145, _val146); + _key155 = iprot.readBinary(); + _val156 = iprot.readBinary(); + struct.attributes.put(_key155, _val156); } } struct.setAttributesIsSet(true); @@ -22001,14 +22947,14 @@ public class Hbase { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list148 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list148.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem149; - for (int _i150 = 0; _i150 < _list148.size; ++_i150) + org.apache.thrift.protocol.TList _list158 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list158.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem159; + for (int _i160 = 0; _i160 < _list158.size; ++_i160) { - _elem149 = new TRowResult(); - _elem149.read(iprot); - struct.success.add(_elem149); + _elem159 = new TRowResult(); + _elem159.read(iprot); + struct.success.add(_elem159); } iprot.readListEnd(); } @@ -22045,9 +22991,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TRowResult _iter151 : struct.success) + for (TRowResult _iter161 : struct.success) { - _iter151.write(oprot); + _iter161.write(oprot); } oprot.writeListEnd(); } @@ -22086,9 +23032,9 @@ public class Hbase { if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TRowResult _iter152 : struct.success) + for (TRowResult _iter162 : struct.success) { - _iter152.write(oprot); + _iter162.write(oprot); } } } @@ -22103,14 +23049,14 @@ public class Hbase { java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list153 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list153.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem154; - for (int _i155 = 0; _i155 < _list153.size; ++_i155) + org.apache.thrift.protocol.TList _list163 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list163.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem164; + for (int _i165 = 0; _i165 < _list163.size; ++_i165) { - _elem154 = new TRowResult(); - _elem154.read(iprot); - struct.success.add(_elem154); + _elem164 = new TRowResult(); + _elem164.read(iprot); + struct.success.add(_elem164); } } struct.setSuccessIsSet(true); @@ -22807,13 +23753,13 @@ public class Hbase { case 3: // COLUMNS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list156 = iprot.readListBegin(); - struct.columns = new java.util.ArrayList(_list156.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem157; - for (int _i158 = 0; _i158 < _list156.size; ++_i158) + org.apache.thrift.protocol.TList _list166 = iprot.readListBegin(); + struct.columns = new java.util.ArrayList(_list166.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem167; + for (int _i168 = 0; _i168 < _list166.size; ++_i168) { - _elem157 = iprot.readBinary(); - struct.columns.add(_elem157); + _elem167 = iprot.readBinary(); + struct.columns.add(_elem167); } iprot.readListEnd(); } @@ -22825,15 +23771,15 @@ public class Hbase { case 4: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map159 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map159.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key160; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val161; - for (int _i162 = 0; _i162 < _map159.size; ++_i162) + org.apache.thrift.protocol.TMap _map169 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map169.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key170; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val171; + for (int _i172 = 0; _i172 < _map169.size; ++_i172) { - _key160 = iprot.readBinary(); - _val161 = iprot.readBinary(); - struct.attributes.put(_key160, _val161); + _key170 = iprot.readBinary(); + _val171 = iprot.readBinary(); + struct.attributes.put(_key170, _val171); } iprot.readMapEnd(); } @@ -22871,9 +23817,9 @@ public class Hbase { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size())); - for (java.nio.ByteBuffer _iter163 : struct.columns) + for (java.nio.ByteBuffer _iter173 : struct.columns) { - oprot.writeBinary(_iter163); + oprot.writeBinary(_iter173); } oprot.writeListEnd(); } @@ -22883,10 +23829,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter164 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter174 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter164.getKey()); - oprot.writeBinary(_iter164.getValue()); + oprot.writeBinary(_iter174.getKey()); + oprot.writeBinary(_iter174.getValue()); } oprot.writeMapEnd(); } @@ -22932,19 +23878,19 @@ public class Hbase { if (struct.isSetColumns()) { { oprot.writeI32(struct.columns.size()); - for (java.nio.ByteBuffer _iter165 : struct.columns) + for (java.nio.ByteBuffer _iter175 : struct.columns) { - oprot.writeBinary(_iter165); + oprot.writeBinary(_iter175); } } } if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter166 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter176 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter166.getKey()); - oprot.writeBinary(_iter166.getValue()); + oprot.writeBinary(_iter176.getKey()); + oprot.writeBinary(_iter176.getValue()); } } } @@ -22964,28 +23910,28 @@ public class Hbase { } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list167 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.columns = new java.util.ArrayList(_list167.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem168; - for (int _i169 = 0; _i169 < _list167.size; ++_i169) + org.apache.thrift.protocol.TList _list177 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.columns = new java.util.ArrayList(_list177.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem178; + for (int _i179 = 0; _i179 < _list177.size; ++_i179) { - _elem168 = iprot.readBinary(); - struct.columns.add(_elem168); + _elem178 = iprot.readBinary(); + struct.columns.add(_elem178); } } struct.setColumnsIsSet(true); } if (incoming.get(3)) { { - org.apache.thrift.protocol.TMap _map170 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map170.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key171; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val172; - for (int _i173 = 0; _i173 < _map170.size; ++_i173) + org.apache.thrift.protocol.TMap _map180 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map180.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key181; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val182; + for (int _i183 = 0; _i183 < _map180.size; ++_i183) { - _key171 = iprot.readBinary(); - _val172 = iprot.readBinary(); - struct.attributes.put(_key171, _val172); + _key181 = iprot.readBinary(); + _val182 = iprot.readBinary(); + struct.attributes.put(_key181, _val182); } } struct.setAttributesIsSet(true); @@ -23398,14 +24344,14 @@ public class Hbase { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list174 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list174.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem175; - for (int _i176 = 0; _i176 < _list174.size; ++_i176) + org.apache.thrift.protocol.TList _list184 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list184.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem185; + for (int _i186 = 0; _i186 < _list184.size; ++_i186) { - _elem175 = new TRowResult(); - _elem175.read(iprot); - struct.success.add(_elem175); + _elem185 = new TRowResult(); + _elem185.read(iprot); + struct.success.add(_elem185); } iprot.readListEnd(); } @@ -23442,9 +24388,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TRowResult _iter177 : struct.success) + for (TRowResult _iter187 : struct.success) { - _iter177.write(oprot); + _iter187.write(oprot); } oprot.writeListEnd(); } @@ -23483,9 +24429,9 @@ public class Hbase { if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TRowResult _iter178 : struct.success) + for (TRowResult _iter188 : struct.success) { - _iter178.write(oprot); + _iter188.write(oprot); } } } @@ -23500,14 +24446,14 @@ public class Hbase { java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list179 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list179.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem180; - for (int _i181 = 0; _i181 < _list179.size; ++_i181) + org.apache.thrift.protocol.TList _list189 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list189.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem190; + for (int _i191 = 0; _i191 < _list189.size; ++_i191) { - _elem180 = new TRowResult(); - _elem180.read(iprot); - struct.success.add(_elem180); + _elem190 = new TRowResult(); + _elem190.read(iprot); + struct.success.add(_elem190); } } struct.setSuccessIsSet(true); @@ -24188,15 +25134,15 @@ public class Hbase { case 4: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map182 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map182.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key183; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val184; - for (int _i185 = 0; _i185 < _map182.size; ++_i185) + org.apache.thrift.protocol.TMap _map192 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map192.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key193; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val194; + for (int _i195 = 0; _i195 < _map192.size; ++_i195) { - _key183 = iprot.readBinary(); - _val184 = iprot.readBinary(); - struct.attributes.put(_key183, _val184); + _key193 = iprot.readBinary(); + _val194 = iprot.readBinary(); + struct.attributes.put(_key193, _val194); } iprot.readMapEnd(); } @@ -24237,10 +25183,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter186 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter196 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter186.getKey()); - oprot.writeBinary(_iter186.getValue()); + oprot.writeBinary(_iter196.getKey()); + oprot.writeBinary(_iter196.getValue()); } oprot.writeMapEnd(); } @@ -24289,10 +25235,10 @@ public class Hbase { if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter187 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter197 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter187.getKey()); - oprot.writeBinary(_iter187.getValue()); + oprot.writeBinary(_iter197.getKey()); + oprot.writeBinary(_iter197.getValue()); } } } @@ -24316,15 +25262,15 @@ public class Hbase { } if (incoming.get(3)) { { - org.apache.thrift.protocol.TMap _map188 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map188.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key189; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val190; - for (int _i191 = 0; _i191 < _map188.size; ++_i191) + org.apache.thrift.protocol.TMap _map198 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map198.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key199; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val200; + for (int _i201 = 0; _i201 < _map198.size; ++_i201) { - _key189 = iprot.readBinary(); - _val190 = iprot.readBinary(); - struct.attributes.put(_key189, _val190); + _key199 = iprot.readBinary(); + _val200 = iprot.readBinary(); + struct.attributes.put(_key199, _val200); } } struct.setAttributesIsSet(true); @@ -24737,14 +25683,14 @@ public class Hbase { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list192 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list192.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem193; - for (int _i194 = 0; _i194 < _list192.size; ++_i194) + org.apache.thrift.protocol.TList _list202 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list202.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem203; + for (int _i204 = 0; _i204 < _list202.size; ++_i204) { - _elem193 = new TRowResult(); - _elem193.read(iprot); - struct.success.add(_elem193); + _elem203 = new TRowResult(); + _elem203.read(iprot); + struct.success.add(_elem203); } iprot.readListEnd(); } @@ -24781,9 +25727,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TRowResult _iter195 : struct.success) + for (TRowResult _iter205 : struct.success) { - _iter195.write(oprot); + _iter205.write(oprot); } oprot.writeListEnd(); } @@ -24822,9 +25768,9 @@ public class Hbase { if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TRowResult _iter196 : struct.success) + for (TRowResult _iter206 : struct.success) { - _iter196.write(oprot); + _iter206.write(oprot); } } } @@ -24839,14 +25785,14 @@ public class Hbase { java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list197 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list197.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem198; - for (int _i199 = 0; _i199 < _list197.size; ++_i199) + org.apache.thrift.protocol.TList _list207 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list207.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem208; + for (int _i209 = 0; _i209 < _list207.size; ++_i209) { - _elem198 = new TRowResult(); - _elem198.read(iprot); - struct.success.add(_elem198); + _elem208 = new TRowResult(); + _elem208.read(iprot); + struct.success.add(_elem208); } } struct.setSuccessIsSet(true); @@ -25622,13 +26568,13 @@ public class Hbase { case 3: // COLUMNS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list200 = iprot.readListBegin(); - struct.columns = new java.util.ArrayList(_list200.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem201; - for (int _i202 = 0; _i202 < _list200.size; ++_i202) + org.apache.thrift.protocol.TList _list210 = iprot.readListBegin(); + struct.columns = new java.util.ArrayList(_list210.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem211; + for (int _i212 = 0; _i212 < _list210.size; ++_i212) { - _elem201 = iprot.readBinary(); - struct.columns.add(_elem201); + _elem211 = iprot.readBinary(); + struct.columns.add(_elem211); } iprot.readListEnd(); } @@ -25648,15 +26594,15 @@ public class Hbase { case 5: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map203 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map203.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key204; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val205; - for (int _i206 = 0; _i206 < _map203.size; ++_i206) + org.apache.thrift.protocol.TMap _map213 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map213.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key214; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val215; + for (int _i216 = 0; _i216 < _map213.size; ++_i216) { - _key204 = iprot.readBinary(); - _val205 = iprot.readBinary(); - struct.attributes.put(_key204, _val205); + _key214 = iprot.readBinary(); + _val215 = iprot.readBinary(); + struct.attributes.put(_key214, _val215); } iprot.readMapEnd(); } @@ -25694,9 +26640,9 @@ public class Hbase { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size())); - for (java.nio.ByteBuffer _iter207 : struct.columns) + for (java.nio.ByteBuffer _iter217 : struct.columns) { - oprot.writeBinary(_iter207); + oprot.writeBinary(_iter217); } oprot.writeListEnd(); } @@ -25709,10 +26655,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter208 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter218 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter208.getKey()); - oprot.writeBinary(_iter208.getValue()); + oprot.writeBinary(_iter218.getKey()); + oprot.writeBinary(_iter218.getValue()); } oprot.writeMapEnd(); } @@ -25761,9 +26707,9 @@ public class Hbase { if (struct.isSetColumns()) { { oprot.writeI32(struct.columns.size()); - for (java.nio.ByteBuffer _iter209 : struct.columns) + for (java.nio.ByteBuffer _iter219 : struct.columns) { - oprot.writeBinary(_iter209); + oprot.writeBinary(_iter219); } } } @@ -25773,10 +26719,10 @@ public class Hbase { if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter210 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter220 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter210.getKey()); - oprot.writeBinary(_iter210.getValue()); + oprot.writeBinary(_iter220.getKey()); + oprot.writeBinary(_iter220.getValue()); } } } @@ -25796,13 +26742,13 @@ public class Hbase { } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list211 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.columns = new java.util.ArrayList(_list211.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem212; - for (int _i213 = 0; _i213 < _list211.size; ++_i213) + org.apache.thrift.protocol.TList _list221 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.columns = new java.util.ArrayList(_list221.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem222; + for (int _i223 = 0; _i223 < _list221.size; ++_i223) { - _elem212 = iprot.readBinary(); - struct.columns.add(_elem212); + _elem222 = iprot.readBinary(); + struct.columns.add(_elem222); } } struct.setColumnsIsSet(true); @@ -25813,15 +26759,15 @@ public class Hbase { } if (incoming.get(4)) { { - org.apache.thrift.protocol.TMap _map214 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map214.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key215; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val216; - for (int _i217 = 0; _i217 < _map214.size; ++_i217) + org.apache.thrift.protocol.TMap _map224 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map224.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key225; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val226; + for (int _i227 = 0; _i227 < _map224.size; ++_i227) { - _key215 = iprot.readBinary(); - _val216 = iprot.readBinary(); - struct.attributes.put(_key215, _val216); + _key225 = iprot.readBinary(); + _val226 = iprot.readBinary(); + struct.attributes.put(_key225, _val226); } } struct.setAttributesIsSet(true); @@ -26234,14 +27180,14 @@ public class Hbase { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list218 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list218.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem219; - for (int _i220 = 0; _i220 < _list218.size; ++_i220) + org.apache.thrift.protocol.TList _list228 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list228.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem229; + for (int _i230 = 0; _i230 < _list228.size; ++_i230) { - _elem219 = new TRowResult(); - _elem219.read(iprot); - struct.success.add(_elem219); + _elem229 = new TRowResult(); + _elem229.read(iprot); + struct.success.add(_elem229); } iprot.readListEnd(); } @@ -26278,9 +27224,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TRowResult _iter221 : struct.success) + for (TRowResult _iter231 : struct.success) { - _iter221.write(oprot); + _iter231.write(oprot); } oprot.writeListEnd(); } @@ -26319,9 +27265,9 @@ public class Hbase { if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TRowResult _iter222 : struct.success) + for (TRowResult _iter232 : struct.success) { - _iter222.write(oprot); + _iter232.write(oprot); } } } @@ -26336,14 +27282,14 @@ public class Hbase { java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list223 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list223.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem224; - for (int _i225 = 0; _i225 < _list223.size; ++_i225) + org.apache.thrift.protocol.TList _list233 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list233.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem234; + for (int _i235 = 0; _i235 < _list233.size; ++_i235) { - _elem224 = new TRowResult(); - _elem224.read(iprot); - struct.success.add(_elem224); + _elem234 = new TRowResult(); + _elem234.read(iprot); + struct.success.add(_elem234); } } struct.setSuccessIsSet(true); @@ -26925,13 +27871,13 @@ public class Hbase { case 2: // ROWS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list226 = iprot.readListBegin(); - struct.rows = new java.util.ArrayList(_list226.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem227; - for (int _i228 = 0; _i228 < _list226.size; ++_i228) + org.apache.thrift.protocol.TList _list236 = iprot.readListBegin(); + struct.rows = new java.util.ArrayList(_list236.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem237; + for (int _i238 = 0; _i238 < _list236.size; ++_i238) { - _elem227 = iprot.readBinary(); - struct.rows.add(_elem227); + _elem237 = iprot.readBinary(); + struct.rows.add(_elem237); } iprot.readListEnd(); } @@ -26943,15 +27889,15 @@ public class Hbase { case 3: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map229 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map229.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key230; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val231; - for (int _i232 = 0; _i232 < _map229.size; ++_i232) + org.apache.thrift.protocol.TMap _map239 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map239.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key240; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val241; + for (int _i242 = 0; _i242 < _map239.size; ++_i242) { - _key230 = iprot.readBinary(); - _val231 = iprot.readBinary(); - struct.attributes.put(_key230, _val231); + _key240 = iprot.readBinary(); + _val241 = iprot.readBinary(); + struct.attributes.put(_key240, _val241); } iprot.readMapEnd(); } @@ -26984,9 +27930,9 @@ public class Hbase { oprot.writeFieldBegin(ROWS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.rows.size())); - for (java.nio.ByteBuffer _iter233 : struct.rows) + for (java.nio.ByteBuffer _iter243 : struct.rows) { - oprot.writeBinary(_iter233); + oprot.writeBinary(_iter243); } oprot.writeListEnd(); } @@ -26996,10 +27942,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter234 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter244 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter234.getKey()); - oprot.writeBinary(_iter234.getValue()); + oprot.writeBinary(_iter244.getKey()); + oprot.writeBinary(_iter244.getValue()); } oprot.writeMapEnd(); } @@ -27039,19 +27985,19 @@ public class Hbase { if (struct.isSetRows()) { { oprot.writeI32(struct.rows.size()); - for (java.nio.ByteBuffer _iter235 : struct.rows) + for (java.nio.ByteBuffer _iter245 : struct.rows) { - oprot.writeBinary(_iter235); + oprot.writeBinary(_iter245); } } } if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter236 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter246 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter236.getKey()); - oprot.writeBinary(_iter236.getValue()); + oprot.writeBinary(_iter246.getKey()); + oprot.writeBinary(_iter246.getValue()); } } } @@ -27067,28 +28013,28 @@ public class Hbase { } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list237 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.rows = new java.util.ArrayList(_list237.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem238; - for (int _i239 = 0; _i239 < _list237.size; ++_i239) + org.apache.thrift.protocol.TList _list247 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.rows = new java.util.ArrayList(_list247.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem248; + for (int _i249 = 0; _i249 < _list247.size; ++_i249) { - _elem238 = iprot.readBinary(); - struct.rows.add(_elem238); + _elem248 = iprot.readBinary(); + struct.rows.add(_elem248); } } struct.setRowsIsSet(true); } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map240 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map240.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key241; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val242; - for (int _i243 = 0; _i243 < _map240.size; ++_i243) + org.apache.thrift.protocol.TMap _map250 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map250.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key251; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val252; + for (int _i253 = 0; _i253 < _map250.size; ++_i253) { - _key241 = iprot.readBinary(); - _val242 = iprot.readBinary(); - struct.attributes.put(_key241, _val242); + _key251 = iprot.readBinary(); + _val252 = iprot.readBinary(); + struct.attributes.put(_key251, _val252); } } struct.setAttributesIsSet(true); @@ -27501,14 +28447,14 @@ public class Hbase { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list244 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list244.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem245; - for (int _i246 = 0; _i246 < _list244.size; ++_i246) + org.apache.thrift.protocol.TList _list254 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list254.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem255; + for (int _i256 = 0; _i256 < _list254.size; ++_i256) { - _elem245 = new TRowResult(); - _elem245.read(iprot); - struct.success.add(_elem245); + _elem255 = new TRowResult(); + _elem255.read(iprot); + struct.success.add(_elem255); } iprot.readListEnd(); } @@ -27545,9 +28491,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TRowResult _iter247 : struct.success) + for (TRowResult _iter257 : struct.success) { - _iter247.write(oprot); + _iter257.write(oprot); } oprot.writeListEnd(); } @@ -27586,9 +28532,9 @@ public class Hbase { if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TRowResult _iter248 : struct.success) + for (TRowResult _iter258 : struct.success) { - _iter248.write(oprot); + _iter258.write(oprot); } } } @@ -27603,14 +28549,14 @@ public class Hbase { java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list249 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list249.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem250; - for (int _i251 = 0; _i251 < _list249.size; ++_i251) + org.apache.thrift.protocol.TList _list259 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list259.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem260; + for (int _i261 = 0; _i261 < _list259.size; ++_i261) { - _elem250 = new TRowResult(); - _elem250.read(iprot); - struct.success.add(_elem250); + _elem260 = new TRowResult(); + _elem260.read(iprot); + struct.success.add(_elem260); } } struct.setSuccessIsSet(true); @@ -28307,13 +29253,13 @@ public class Hbase { case 2: // ROWS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list252 = iprot.readListBegin(); - struct.rows = new java.util.ArrayList(_list252.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem253; - for (int _i254 = 0; _i254 < _list252.size; ++_i254) + org.apache.thrift.protocol.TList _list262 = iprot.readListBegin(); + struct.rows = new java.util.ArrayList(_list262.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem263; + for (int _i264 = 0; _i264 < _list262.size; ++_i264) { - _elem253 = iprot.readBinary(); - struct.rows.add(_elem253); + _elem263 = iprot.readBinary(); + struct.rows.add(_elem263); } iprot.readListEnd(); } @@ -28325,13 +29271,13 @@ public class Hbase { case 3: // COLUMNS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list255 = iprot.readListBegin(); - struct.columns = new java.util.ArrayList(_list255.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem256; - for (int _i257 = 0; _i257 < _list255.size; ++_i257) + org.apache.thrift.protocol.TList _list265 = iprot.readListBegin(); + struct.columns = new java.util.ArrayList(_list265.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem266; + for (int _i267 = 0; _i267 < _list265.size; ++_i267) { - _elem256 = iprot.readBinary(); - struct.columns.add(_elem256); + _elem266 = iprot.readBinary(); + struct.columns.add(_elem266); } iprot.readListEnd(); } @@ -28343,15 +29289,15 @@ public class Hbase { case 4: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map258 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map258.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key259; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val260; - for (int _i261 = 0; _i261 < _map258.size; ++_i261) + org.apache.thrift.protocol.TMap _map268 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map268.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key269; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val270; + for (int _i271 = 0; _i271 < _map268.size; ++_i271) { - _key259 = iprot.readBinary(); - _val260 = iprot.readBinary(); - struct.attributes.put(_key259, _val260); + _key269 = iprot.readBinary(); + _val270 = iprot.readBinary(); + struct.attributes.put(_key269, _val270); } iprot.readMapEnd(); } @@ -28384,9 +29330,9 @@ public class Hbase { oprot.writeFieldBegin(ROWS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.rows.size())); - for (java.nio.ByteBuffer _iter262 : struct.rows) + for (java.nio.ByteBuffer _iter272 : struct.rows) { - oprot.writeBinary(_iter262); + oprot.writeBinary(_iter272); } oprot.writeListEnd(); } @@ -28396,9 +29342,9 @@ public class Hbase { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size())); - for (java.nio.ByteBuffer _iter263 : struct.columns) + for (java.nio.ByteBuffer _iter273 : struct.columns) { - oprot.writeBinary(_iter263); + oprot.writeBinary(_iter273); } oprot.writeListEnd(); } @@ -28408,10 +29354,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter264 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter274 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter264.getKey()); - oprot.writeBinary(_iter264.getValue()); + oprot.writeBinary(_iter274.getKey()); + oprot.writeBinary(_iter274.getValue()); } oprot.writeMapEnd(); } @@ -28454,28 +29400,28 @@ public class Hbase { if (struct.isSetRows()) { { oprot.writeI32(struct.rows.size()); - for (java.nio.ByteBuffer _iter265 : struct.rows) + for (java.nio.ByteBuffer _iter275 : struct.rows) { - oprot.writeBinary(_iter265); + oprot.writeBinary(_iter275); } } } if (struct.isSetColumns()) { { oprot.writeI32(struct.columns.size()); - for (java.nio.ByteBuffer _iter266 : struct.columns) + for (java.nio.ByteBuffer _iter276 : struct.columns) { - oprot.writeBinary(_iter266); + oprot.writeBinary(_iter276); } } } if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter267 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter277 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter267.getKey()); - oprot.writeBinary(_iter267.getValue()); + oprot.writeBinary(_iter277.getKey()); + oprot.writeBinary(_iter277.getValue()); } } } @@ -28491,41 +29437,41 @@ public class Hbase { } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list268 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.rows = new java.util.ArrayList(_list268.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem269; - for (int _i270 = 0; _i270 < _list268.size; ++_i270) + org.apache.thrift.protocol.TList _list278 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.rows = new java.util.ArrayList(_list278.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem279; + for (int _i280 = 0; _i280 < _list278.size; ++_i280) { - _elem269 = iprot.readBinary(); - struct.rows.add(_elem269); + _elem279 = iprot.readBinary(); + struct.rows.add(_elem279); } } struct.setRowsIsSet(true); } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list271 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.columns = new java.util.ArrayList(_list271.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem272; - for (int _i273 = 0; _i273 < _list271.size; ++_i273) + org.apache.thrift.protocol.TList _list281 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.columns = new java.util.ArrayList(_list281.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem282; + for (int _i283 = 0; _i283 < _list281.size; ++_i283) { - _elem272 = iprot.readBinary(); - struct.columns.add(_elem272); + _elem282 = iprot.readBinary(); + struct.columns.add(_elem282); } } struct.setColumnsIsSet(true); } if (incoming.get(3)) { { - org.apache.thrift.protocol.TMap _map274 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map274.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key275; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val276; - for (int _i277 = 0; _i277 < _map274.size; ++_i277) + org.apache.thrift.protocol.TMap _map284 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map284.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key285; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val286; + for (int _i287 = 0; _i287 < _map284.size; ++_i287) { - _key275 = iprot.readBinary(); - _val276 = iprot.readBinary(); - struct.attributes.put(_key275, _val276); + _key285 = iprot.readBinary(); + _val286 = iprot.readBinary(); + struct.attributes.put(_key285, _val286); } } struct.setAttributesIsSet(true); @@ -28938,14 +29884,14 @@ public class Hbase { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list278 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list278.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem279; - for (int _i280 = 0; _i280 < _list278.size; ++_i280) + org.apache.thrift.protocol.TList _list288 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list288.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem289; + for (int _i290 = 0; _i290 < _list288.size; ++_i290) { - _elem279 = new TRowResult(); - _elem279.read(iprot); - struct.success.add(_elem279); + _elem289 = new TRowResult(); + _elem289.read(iprot); + struct.success.add(_elem289); } iprot.readListEnd(); } @@ -28982,9 +29928,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TRowResult _iter281 : struct.success) + for (TRowResult _iter291 : struct.success) { - _iter281.write(oprot); + _iter291.write(oprot); } oprot.writeListEnd(); } @@ -29023,9 +29969,9 @@ public class Hbase { if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TRowResult _iter282 : struct.success) + for (TRowResult _iter292 : struct.success) { - _iter282.write(oprot); + _iter292.write(oprot); } } } @@ -29040,14 +29986,14 @@ public class Hbase { java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list283 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list283.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem284; - for (int _i285 = 0; _i285 < _list283.size; ++_i285) + org.apache.thrift.protocol.TList _list293 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list293.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem294; + for (int _i295 = 0; _i295 < _list293.size; ++_i295) { - _elem284 = new TRowResult(); - _elem284.read(iprot); - struct.success.add(_elem284); + _elem294 = new TRowResult(); + _elem294.read(iprot); + struct.success.add(_elem294); } } struct.setSuccessIsSet(true); @@ -29720,13 +30666,13 @@ public class Hbase { case 2: // ROWS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list286 = iprot.readListBegin(); - struct.rows = new java.util.ArrayList(_list286.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem287; - for (int _i288 = 0; _i288 < _list286.size; ++_i288) + org.apache.thrift.protocol.TList _list296 = iprot.readListBegin(); + struct.rows = new java.util.ArrayList(_list296.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem297; + for (int _i298 = 0; _i298 < _list296.size; ++_i298) { - _elem287 = iprot.readBinary(); - struct.rows.add(_elem287); + _elem297 = iprot.readBinary(); + struct.rows.add(_elem297); } iprot.readListEnd(); } @@ -29746,15 +30692,15 @@ public class Hbase { case 4: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map289 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map289.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key290; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val291; - for (int _i292 = 0; _i292 < _map289.size; ++_i292) + org.apache.thrift.protocol.TMap _map299 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map299.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key300; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val301; + for (int _i302 = 0; _i302 < _map299.size; ++_i302) { - _key290 = iprot.readBinary(); - _val291 = iprot.readBinary(); - struct.attributes.put(_key290, _val291); + _key300 = iprot.readBinary(); + _val301 = iprot.readBinary(); + struct.attributes.put(_key300, _val301); } iprot.readMapEnd(); } @@ -29787,9 +30733,9 @@ public class Hbase { oprot.writeFieldBegin(ROWS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.rows.size())); - for (java.nio.ByteBuffer _iter293 : struct.rows) + for (java.nio.ByteBuffer _iter303 : struct.rows) { - oprot.writeBinary(_iter293); + oprot.writeBinary(_iter303); } oprot.writeListEnd(); } @@ -29802,10 +30748,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter294 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter304 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter294.getKey()); - oprot.writeBinary(_iter294.getValue()); + oprot.writeBinary(_iter304.getKey()); + oprot.writeBinary(_iter304.getValue()); } oprot.writeMapEnd(); } @@ -29848,9 +30794,9 @@ public class Hbase { if (struct.isSetRows()) { { oprot.writeI32(struct.rows.size()); - for (java.nio.ByteBuffer _iter295 : struct.rows) + for (java.nio.ByteBuffer _iter305 : struct.rows) { - oprot.writeBinary(_iter295); + oprot.writeBinary(_iter305); } } } @@ -29860,10 +30806,10 @@ public class Hbase { if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter296 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter306 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter296.getKey()); - oprot.writeBinary(_iter296.getValue()); + oprot.writeBinary(_iter306.getKey()); + oprot.writeBinary(_iter306.getValue()); } } } @@ -29879,13 +30825,13 @@ public class Hbase { } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list297 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.rows = new java.util.ArrayList(_list297.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem298; - for (int _i299 = 0; _i299 < _list297.size; ++_i299) + org.apache.thrift.protocol.TList _list307 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.rows = new java.util.ArrayList(_list307.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem308; + for (int _i309 = 0; _i309 < _list307.size; ++_i309) { - _elem298 = iprot.readBinary(); - struct.rows.add(_elem298); + _elem308 = iprot.readBinary(); + struct.rows.add(_elem308); } } struct.setRowsIsSet(true); @@ -29896,15 +30842,15 @@ public class Hbase { } if (incoming.get(3)) { { - org.apache.thrift.protocol.TMap _map300 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map300.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key301; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val302; - for (int _i303 = 0; _i303 < _map300.size; ++_i303) + org.apache.thrift.protocol.TMap _map310 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map310.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key311; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val312; + for (int _i313 = 0; _i313 < _map310.size; ++_i313) { - _key301 = iprot.readBinary(); - _val302 = iprot.readBinary(); - struct.attributes.put(_key301, _val302); + _key311 = iprot.readBinary(); + _val312 = iprot.readBinary(); + struct.attributes.put(_key311, _val312); } } struct.setAttributesIsSet(true); @@ -30317,14 +31263,14 @@ public class Hbase { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list304 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list304.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem305; - for (int _i306 = 0; _i306 < _list304.size; ++_i306) + org.apache.thrift.protocol.TList _list314 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list314.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem315; + for (int _i316 = 0; _i316 < _list314.size; ++_i316) { - _elem305 = new TRowResult(); - _elem305.read(iprot); - struct.success.add(_elem305); + _elem315 = new TRowResult(); + _elem315.read(iprot); + struct.success.add(_elem315); } iprot.readListEnd(); } @@ -30361,9 +31307,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TRowResult _iter307 : struct.success) + for (TRowResult _iter317 : struct.success) { - _iter307.write(oprot); + _iter317.write(oprot); } oprot.writeListEnd(); } @@ -30402,9 +31348,9 @@ public class Hbase { if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TRowResult _iter308 : struct.success) + for (TRowResult _iter318 : struct.success) { - _iter308.write(oprot); + _iter318.write(oprot); } } } @@ -30419,14 +31365,14 @@ public class Hbase { java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list309 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list309.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem310; - for (int _i311 = 0; _i311 < _list309.size; ++_i311) + org.apache.thrift.protocol.TList _list319 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list319.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem320; + for (int _i321 = 0; _i321 < _list319.size; ++_i321) { - _elem310 = new TRowResult(); - _elem310.read(iprot); - struct.success.add(_elem310); + _elem320 = new TRowResult(); + _elem320.read(iprot); + struct.success.add(_elem320); } } struct.setSuccessIsSet(true); @@ -31202,13 +32148,13 @@ public class Hbase { case 2: // ROWS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list312 = iprot.readListBegin(); - struct.rows = new java.util.ArrayList(_list312.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem313; - for (int _i314 = 0; _i314 < _list312.size; ++_i314) + org.apache.thrift.protocol.TList _list322 = iprot.readListBegin(); + struct.rows = new java.util.ArrayList(_list322.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem323; + for (int _i324 = 0; _i324 < _list322.size; ++_i324) { - _elem313 = iprot.readBinary(); - struct.rows.add(_elem313); + _elem323 = iprot.readBinary(); + struct.rows.add(_elem323); } iprot.readListEnd(); } @@ -31220,13 +32166,13 @@ public class Hbase { case 3: // COLUMNS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list315 = iprot.readListBegin(); - struct.columns = new java.util.ArrayList(_list315.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem316; - for (int _i317 = 0; _i317 < _list315.size; ++_i317) + org.apache.thrift.protocol.TList _list325 = iprot.readListBegin(); + struct.columns = new java.util.ArrayList(_list325.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem326; + for (int _i327 = 0; _i327 < _list325.size; ++_i327) { - _elem316 = iprot.readBinary(); - struct.columns.add(_elem316); + _elem326 = iprot.readBinary(); + struct.columns.add(_elem326); } iprot.readListEnd(); } @@ -31246,15 +32192,15 @@ public class Hbase { case 5: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map318 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map318.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key319; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val320; - for (int _i321 = 0; _i321 < _map318.size; ++_i321) + org.apache.thrift.protocol.TMap _map328 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map328.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key329; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val330; + for (int _i331 = 0; _i331 < _map328.size; ++_i331) { - _key319 = iprot.readBinary(); - _val320 = iprot.readBinary(); - struct.attributes.put(_key319, _val320); + _key329 = iprot.readBinary(); + _val330 = iprot.readBinary(); + struct.attributes.put(_key329, _val330); } iprot.readMapEnd(); } @@ -31287,9 +32233,9 @@ public class Hbase { oprot.writeFieldBegin(ROWS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.rows.size())); - for (java.nio.ByteBuffer _iter322 : struct.rows) + for (java.nio.ByteBuffer _iter332 : struct.rows) { - oprot.writeBinary(_iter322); + oprot.writeBinary(_iter332); } oprot.writeListEnd(); } @@ -31299,9 +32245,9 @@ public class Hbase { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size())); - for (java.nio.ByteBuffer _iter323 : struct.columns) + for (java.nio.ByteBuffer _iter333 : struct.columns) { - oprot.writeBinary(_iter323); + oprot.writeBinary(_iter333); } oprot.writeListEnd(); } @@ -31314,10 +32260,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter324 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter334 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter324.getKey()); - oprot.writeBinary(_iter324.getValue()); + oprot.writeBinary(_iter334.getKey()); + oprot.writeBinary(_iter334.getValue()); } oprot.writeMapEnd(); } @@ -31363,18 +32309,18 @@ public class Hbase { if (struct.isSetRows()) { { oprot.writeI32(struct.rows.size()); - for (java.nio.ByteBuffer _iter325 : struct.rows) + for (java.nio.ByteBuffer _iter335 : struct.rows) { - oprot.writeBinary(_iter325); + oprot.writeBinary(_iter335); } } } if (struct.isSetColumns()) { { oprot.writeI32(struct.columns.size()); - for (java.nio.ByteBuffer _iter326 : struct.columns) + for (java.nio.ByteBuffer _iter336 : struct.columns) { - oprot.writeBinary(_iter326); + oprot.writeBinary(_iter336); } } } @@ -31384,10 +32330,10 @@ public class Hbase { if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter327 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter337 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter327.getKey()); - oprot.writeBinary(_iter327.getValue()); + oprot.writeBinary(_iter337.getKey()); + oprot.writeBinary(_iter337.getValue()); } } } @@ -31403,26 +32349,26 @@ public class Hbase { } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list328 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.rows = new java.util.ArrayList(_list328.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem329; - for (int _i330 = 0; _i330 < _list328.size; ++_i330) + org.apache.thrift.protocol.TList _list338 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.rows = new java.util.ArrayList(_list338.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem339; + for (int _i340 = 0; _i340 < _list338.size; ++_i340) { - _elem329 = iprot.readBinary(); - struct.rows.add(_elem329); + _elem339 = iprot.readBinary(); + struct.rows.add(_elem339); } } struct.setRowsIsSet(true); } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list331 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.columns = new java.util.ArrayList(_list331.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem332; - for (int _i333 = 0; _i333 < _list331.size; ++_i333) + org.apache.thrift.protocol.TList _list341 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.columns = new java.util.ArrayList(_list341.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem342; + for (int _i343 = 0; _i343 < _list341.size; ++_i343) { - _elem332 = iprot.readBinary(); - struct.columns.add(_elem332); + _elem342 = iprot.readBinary(); + struct.columns.add(_elem342); } } struct.setColumnsIsSet(true); @@ -31433,15 +32379,15 @@ public class Hbase { } if (incoming.get(4)) { { - org.apache.thrift.protocol.TMap _map334 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map334.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key335; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val336; - for (int _i337 = 0; _i337 < _map334.size; ++_i337) + org.apache.thrift.protocol.TMap _map344 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map344.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key345; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val346; + for (int _i347 = 0; _i347 < _map344.size; ++_i347) { - _key335 = iprot.readBinary(); - _val336 = iprot.readBinary(); - struct.attributes.put(_key335, _val336); + _key345 = iprot.readBinary(); + _val346 = iprot.readBinary(); + struct.attributes.put(_key345, _val346); } } struct.setAttributesIsSet(true); @@ -31854,14 +32800,14 @@ public class Hbase { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list338 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list338.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem339; - for (int _i340 = 0; _i340 < _list338.size; ++_i340) + org.apache.thrift.protocol.TList _list348 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list348.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem349; + for (int _i350 = 0; _i350 < _list348.size; ++_i350) { - _elem339 = new TRowResult(); - _elem339.read(iprot); - struct.success.add(_elem339); + _elem349 = new TRowResult(); + _elem349.read(iprot); + struct.success.add(_elem349); } iprot.readListEnd(); } @@ -31898,9 +32844,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TRowResult _iter341 : struct.success) + for (TRowResult _iter351 : struct.success) { - _iter341.write(oprot); + _iter351.write(oprot); } oprot.writeListEnd(); } @@ -31939,9 +32885,9 @@ public class Hbase { if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TRowResult _iter342 : struct.success) + for (TRowResult _iter352 : struct.success) { - _iter342.write(oprot); + _iter352.write(oprot); } } } @@ -31956,14 +32902,14 @@ public class Hbase { java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list343 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list343.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem344; - for (int _i345 = 0; _i345 < _list343.size; ++_i345) + org.apache.thrift.protocol.TList _list353 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list353.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem354; + for (int _i355 = 0; _i355 < _list353.size; ++_i355) { - _elem344 = new TRowResult(); - _elem344.read(iprot); - struct.success.add(_elem344); + _elem354 = new TRowResult(); + _elem354.read(iprot); + struct.success.add(_elem354); } } struct.setSuccessIsSet(true); @@ -32660,14 +33606,14 @@ public class Hbase { case 3: // MUTATIONS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list346 = iprot.readListBegin(); - struct.mutations = new java.util.ArrayList(_list346.size); - @org.apache.thrift.annotation.Nullable Mutation _elem347; - for (int _i348 = 0; _i348 < _list346.size; ++_i348) + org.apache.thrift.protocol.TList _list356 = iprot.readListBegin(); + struct.mutations = new java.util.ArrayList(_list356.size); + @org.apache.thrift.annotation.Nullable Mutation _elem357; + for (int _i358 = 0; _i358 < _list356.size; ++_i358) { - _elem347 = new Mutation(); - _elem347.read(iprot); - struct.mutations.add(_elem347); + _elem357 = new Mutation(); + _elem357.read(iprot); + struct.mutations.add(_elem357); } iprot.readListEnd(); } @@ -32679,15 +33625,15 @@ public class Hbase { case 4: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map349 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map349.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key350; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val351; - for (int _i352 = 0; _i352 < _map349.size; ++_i352) + org.apache.thrift.protocol.TMap _map359 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map359.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key360; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val361; + for (int _i362 = 0; _i362 < _map359.size; ++_i362) { - _key350 = iprot.readBinary(); - _val351 = iprot.readBinary(); - struct.attributes.put(_key350, _val351); + _key360 = iprot.readBinary(); + _val361 = iprot.readBinary(); + struct.attributes.put(_key360, _val361); } iprot.readMapEnd(); } @@ -32725,9 +33671,9 @@ public class Hbase { oprot.writeFieldBegin(MUTATIONS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.mutations.size())); - for (Mutation _iter353 : struct.mutations) + for (Mutation _iter363 : struct.mutations) { - _iter353.write(oprot); + _iter363.write(oprot); } oprot.writeListEnd(); } @@ -32737,10 +33683,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter354 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter364 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter354.getKey()); - oprot.writeBinary(_iter354.getValue()); + oprot.writeBinary(_iter364.getKey()); + oprot.writeBinary(_iter364.getValue()); } oprot.writeMapEnd(); } @@ -32786,19 +33732,19 @@ public class Hbase { if (struct.isSetMutations()) { { oprot.writeI32(struct.mutations.size()); - for (Mutation _iter355 : struct.mutations) + for (Mutation _iter365 : struct.mutations) { - _iter355.write(oprot); + _iter365.write(oprot); } } } if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter356 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter366 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter356.getKey()); - oprot.writeBinary(_iter356.getValue()); + oprot.writeBinary(_iter366.getKey()); + oprot.writeBinary(_iter366.getValue()); } } } @@ -32818,29 +33764,29 @@ public class Hbase { } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list357 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.mutations = new java.util.ArrayList(_list357.size); - @org.apache.thrift.annotation.Nullable Mutation _elem358; - for (int _i359 = 0; _i359 < _list357.size; ++_i359) + org.apache.thrift.protocol.TList _list367 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.mutations = new java.util.ArrayList(_list367.size); + @org.apache.thrift.annotation.Nullable Mutation _elem368; + for (int _i369 = 0; _i369 < _list367.size; ++_i369) { - _elem358 = new Mutation(); - _elem358.read(iprot); - struct.mutations.add(_elem358); + _elem368 = new Mutation(); + _elem368.read(iprot); + struct.mutations.add(_elem368); } } struct.setMutationsIsSet(true); } if (incoming.get(3)) { { - org.apache.thrift.protocol.TMap _map360 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map360.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key361; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val362; - for (int _i363 = 0; _i363 < _map360.size; ++_i363) + org.apache.thrift.protocol.TMap _map370 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map370.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key371; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val372; + for (int _i373 = 0; _i373 < _map370.size; ++_i373) { - _key361 = iprot.readBinary(); - _val362 = iprot.readBinary(); - struct.attributes.put(_key361, _val362); + _key371 = iprot.readBinary(); + _val372 = iprot.readBinary(); + struct.attributes.put(_key371, _val372); } } struct.setAttributesIsSet(true); @@ -34097,14 +35043,14 @@ public class Hbase { case 3: // MUTATIONS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list364 = iprot.readListBegin(); - struct.mutations = new java.util.ArrayList(_list364.size); - @org.apache.thrift.annotation.Nullable Mutation _elem365; - for (int _i366 = 0; _i366 < _list364.size; ++_i366) + org.apache.thrift.protocol.TList _list374 = iprot.readListBegin(); + struct.mutations = new java.util.ArrayList(_list374.size); + @org.apache.thrift.annotation.Nullable Mutation _elem375; + for (int _i376 = 0; _i376 < _list374.size; ++_i376) { - _elem365 = new Mutation(); - _elem365.read(iprot); - struct.mutations.add(_elem365); + _elem375 = new Mutation(); + _elem375.read(iprot); + struct.mutations.add(_elem375); } iprot.readListEnd(); } @@ -34124,15 +35070,15 @@ public class Hbase { case 5: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map367 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map367.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key368; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val369; - for (int _i370 = 0; _i370 < _map367.size; ++_i370) + org.apache.thrift.protocol.TMap _map377 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map377.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key378; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val379; + for (int _i380 = 0; _i380 < _map377.size; ++_i380) { - _key368 = iprot.readBinary(); - _val369 = iprot.readBinary(); - struct.attributes.put(_key368, _val369); + _key378 = iprot.readBinary(); + _val379 = iprot.readBinary(); + struct.attributes.put(_key378, _val379); } iprot.readMapEnd(); } @@ -34170,9 +35116,9 @@ public class Hbase { oprot.writeFieldBegin(MUTATIONS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.mutations.size())); - for (Mutation _iter371 : struct.mutations) + for (Mutation _iter381 : struct.mutations) { - _iter371.write(oprot); + _iter381.write(oprot); } oprot.writeListEnd(); } @@ -34185,10 +35131,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter372 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter382 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter372.getKey()); - oprot.writeBinary(_iter372.getValue()); + oprot.writeBinary(_iter382.getKey()); + oprot.writeBinary(_iter382.getValue()); } oprot.writeMapEnd(); } @@ -34237,9 +35183,9 @@ public class Hbase { if (struct.isSetMutations()) { { oprot.writeI32(struct.mutations.size()); - for (Mutation _iter373 : struct.mutations) + for (Mutation _iter383 : struct.mutations) { - _iter373.write(oprot); + _iter383.write(oprot); } } } @@ -34249,10 +35195,10 @@ public class Hbase { if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter374 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter384 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter374.getKey()); - oprot.writeBinary(_iter374.getValue()); + oprot.writeBinary(_iter384.getKey()); + oprot.writeBinary(_iter384.getValue()); } } } @@ -34272,14 +35218,14 @@ public class Hbase { } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list375 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.mutations = new java.util.ArrayList(_list375.size); - @org.apache.thrift.annotation.Nullable Mutation _elem376; - for (int _i377 = 0; _i377 < _list375.size; ++_i377) + org.apache.thrift.protocol.TList _list385 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.mutations = new java.util.ArrayList(_list385.size); + @org.apache.thrift.annotation.Nullable Mutation _elem386; + for (int _i387 = 0; _i387 < _list385.size; ++_i387) { - _elem376 = new Mutation(); - _elem376.read(iprot); - struct.mutations.add(_elem376); + _elem386 = new Mutation(); + _elem386.read(iprot); + struct.mutations.add(_elem386); } } struct.setMutationsIsSet(true); @@ -34290,15 +35236,15 @@ public class Hbase { } if (incoming.get(4)) { { - org.apache.thrift.protocol.TMap _map378 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map378.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key379; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val380; - for (int _i381 = 0; _i381 < _map378.size; ++_i381) + org.apache.thrift.protocol.TMap _map388 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map388.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key389; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val390; + for (int _i391 = 0; _i391 < _map388.size; ++_i391) { - _key379 = iprot.readBinary(); - _val380 = iprot.readBinary(); - struct.attributes.put(_key379, _val380); + _key389 = iprot.readBinary(); + _val390 = iprot.readBinary(); + struct.attributes.put(_key389, _val390); } } struct.setAttributesIsSet(true); @@ -35349,14 +36295,14 @@ public class Hbase { case 2: // ROW_BATCHES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list382 = iprot.readListBegin(); - struct.rowBatches = new java.util.ArrayList(_list382.size); - @org.apache.thrift.annotation.Nullable BatchMutation _elem383; - for (int _i384 = 0; _i384 < _list382.size; ++_i384) + org.apache.thrift.protocol.TList _list392 = iprot.readListBegin(); + struct.rowBatches = new java.util.ArrayList(_list392.size); + @org.apache.thrift.annotation.Nullable BatchMutation _elem393; + for (int _i394 = 0; _i394 < _list392.size; ++_i394) { - _elem383 = new BatchMutation(); - _elem383.read(iprot); - struct.rowBatches.add(_elem383); + _elem393 = new BatchMutation(); + _elem393.read(iprot); + struct.rowBatches.add(_elem393); } iprot.readListEnd(); } @@ -35368,15 +36314,15 @@ public class Hbase { case 3: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map385 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map385.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key386; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val387; - for (int _i388 = 0; _i388 < _map385.size; ++_i388) + org.apache.thrift.protocol.TMap _map395 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map395.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key396; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val397; + for (int _i398 = 0; _i398 < _map395.size; ++_i398) { - _key386 = iprot.readBinary(); - _val387 = iprot.readBinary(); - struct.attributes.put(_key386, _val387); + _key396 = iprot.readBinary(); + _val397 = iprot.readBinary(); + struct.attributes.put(_key396, _val397); } iprot.readMapEnd(); } @@ -35409,9 +36355,9 @@ public class Hbase { oprot.writeFieldBegin(ROW_BATCHES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.rowBatches.size())); - for (BatchMutation _iter389 : struct.rowBatches) + for (BatchMutation _iter399 : struct.rowBatches) { - _iter389.write(oprot); + _iter399.write(oprot); } oprot.writeListEnd(); } @@ -35421,10 +36367,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter390 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter400 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter390.getKey()); - oprot.writeBinary(_iter390.getValue()); + oprot.writeBinary(_iter400.getKey()); + oprot.writeBinary(_iter400.getValue()); } oprot.writeMapEnd(); } @@ -35464,19 +36410,19 @@ public class Hbase { if (struct.isSetRowBatches()) { { oprot.writeI32(struct.rowBatches.size()); - for (BatchMutation _iter391 : struct.rowBatches) + for (BatchMutation _iter401 : struct.rowBatches) { - _iter391.write(oprot); + _iter401.write(oprot); } } } if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter392 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter402 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter392.getKey()); - oprot.writeBinary(_iter392.getValue()); + oprot.writeBinary(_iter402.getKey()); + oprot.writeBinary(_iter402.getValue()); } } } @@ -35492,29 +36438,29 @@ public class Hbase { } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list393 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.rowBatches = new java.util.ArrayList(_list393.size); - @org.apache.thrift.annotation.Nullable BatchMutation _elem394; - for (int _i395 = 0; _i395 < _list393.size; ++_i395) + org.apache.thrift.protocol.TList _list403 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.rowBatches = new java.util.ArrayList(_list403.size); + @org.apache.thrift.annotation.Nullable BatchMutation _elem404; + for (int _i405 = 0; _i405 < _list403.size; ++_i405) { - _elem394 = new BatchMutation(); - _elem394.read(iprot); - struct.rowBatches.add(_elem394); + _elem404 = new BatchMutation(); + _elem404.read(iprot); + struct.rowBatches.add(_elem404); } } struct.setRowBatchesIsSet(true); } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map396 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map396.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key397; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val398; - for (int _i399 = 0; _i399 < _map396.size; ++_i399) + org.apache.thrift.protocol.TMap _map406 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map406.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key407; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val408; + for (int _i409 = 0; _i409 < _map406.size; ++_i409) { - _key397 = iprot.readBinary(); - _val398 = iprot.readBinary(); - struct.attributes.put(_key397, _val398); + _key407 = iprot.readBinary(); + _val408 = iprot.readBinary(); + struct.attributes.put(_key407, _val408); } } struct.setAttributesIsSet(true); @@ -36656,14 +37602,14 @@ public class Hbase { case 2: // ROW_BATCHES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list400 = iprot.readListBegin(); - struct.rowBatches = new java.util.ArrayList(_list400.size); - @org.apache.thrift.annotation.Nullable BatchMutation _elem401; - for (int _i402 = 0; _i402 < _list400.size; ++_i402) + org.apache.thrift.protocol.TList _list410 = iprot.readListBegin(); + struct.rowBatches = new java.util.ArrayList(_list410.size); + @org.apache.thrift.annotation.Nullable BatchMutation _elem411; + for (int _i412 = 0; _i412 < _list410.size; ++_i412) { - _elem401 = new BatchMutation(); - _elem401.read(iprot); - struct.rowBatches.add(_elem401); + _elem411 = new BatchMutation(); + _elem411.read(iprot); + struct.rowBatches.add(_elem411); } iprot.readListEnd(); } @@ -36683,15 +37629,15 @@ public class Hbase { case 4: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map403 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map403.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key404; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val405; - for (int _i406 = 0; _i406 < _map403.size; ++_i406) + org.apache.thrift.protocol.TMap _map413 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map413.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key414; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val415; + for (int _i416 = 0; _i416 < _map413.size; ++_i416) { - _key404 = iprot.readBinary(); - _val405 = iprot.readBinary(); - struct.attributes.put(_key404, _val405); + _key414 = iprot.readBinary(); + _val415 = iprot.readBinary(); + struct.attributes.put(_key414, _val415); } iprot.readMapEnd(); } @@ -36724,9 +37670,9 @@ public class Hbase { oprot.writeFieldBegin(ROW_BATCHES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.rowBatches.size())); - for (BatchMutation _iter407 : struct.rowBatches) + for (BatchMutation _iter417 : struct.rowBatches) { - _iter407.write(oprot); + _iter417.write(oprot); } oprot.writeListEnd(); } @@ -36739,10 +37685,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter408 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter418 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter408.getKey()); - oprot.writeBinary(_iter408.getValue()); + oprot.writeBinary(_iter418.getKey()); + oprot.writeBinary(_iter418.getValue()); } oprot.writeMapEnd(); } @@ -36785,9 +37731,9 @@ public class Hbase { if (struct.isSetRowBatches()) { { oprot.writeI32(struct.rowBatches.size()); - for (BatchMutation _iter409 : struct.rowBatches) + for (BatchMutation _iter419 : struct.rowBatches) { - _iter409.write(oprot); + _iter419.write(oprot); } } } @@ -36797,10 +37743,10 @@ public class Hbase { if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter410 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter420 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter410.getKey()); - oprot.writeBinary(_iter410.getValue()); + oprot.writeBinary(_iter420.getKey()); + oprot.writeBinary(_iter420.getValue()); } } } @@ -36816,14 +37762,14 @@ public class Hbase { } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list411 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.rowBatches = new java.util.ArrayList(_list411.size); - @org.apache.thrift.annotation.Nullable BatchMutation _elem412; - for (int _i413 = 0; _i413 < _list411.size; ++_i413) + org.apache.thrift.protocol.TList _list421 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.rowBatches = new java.util.ArrayList(_list421.size); + @org.apache.thrift.annotation.Nullable BatchMutation _elem422; + for (int _i423 = 0; _i423 < _list421.size; ++_i423) { - _elem412 = new BatchMutation(); - _elem412.read(iprot); - struct.rowBatches.add(_elem412); + _elem422 = new BatchMutation(); + _elem422.read(iprot); + struct.rowBatches.add(_elem422); } } struct.setRowBatchesIsSet(true); @@ -36834,15 +37780,15 @@ public class Hbase { } if (incoming.get(3)) { { - org.apache.thrift.protocol.TMap _map414 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map414.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key415; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val416; - for (int _i417 = 0; _i417 < _map414.size; ++_i417) + org.apache.thrift.protocol.TMap _map424 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map424.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key425; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val426; + for (int _i427 = 0; _i427 < _map424.size; ++_i427) { - _key415 = iprot.readBinary(); - _val416 = iprot.readBinary(); - struct.attributes.put(_key415, _val416); + _key425 = iprot.readBinary(); + _val426 = iprot.readBinary(); + struct.attributes.put(_key425, _val426); } } struct.setAttributesIsSet(true); @@ -39346,15 +40292,15 @@ public class Hbase { case 4: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map418 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map418.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key419; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val420; - for (int _i421 = 0; _i421 < _map418.size; ++_i421) + org.apache.thrift.protocol.TMap _map428 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map428.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key429; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val430; + for (int _i431 = 0; _i431 < _map428.size; ++_i431) { - _key419 = iprot.readBinary(); - _val420 = iprot.readBinary(); - struct.attributes.put(_key419, _val420); + _key429 = iprot.readBinary(); + _val430 = iprot.readBinary(); + struct.attributes.put(_key429, _val430); } iprot.readMapEnd(); } @@ -39397,10 +40343,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter422 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter432 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter422.getKey()); - oprot.writeBinary(_iter422.getValue()); + oprot.writeBinary(_iter432.getKey()); + oprot.writeBinary(_iter432.getValue()); } oprot.writeMapEnd(); } @@ -39449,10 +40395,10 @@ public class Hbase { if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter423 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter433 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter423.getKey()); - oprot.writeBinary(_iter423.getValue()); + oprot.writeBinary(_iter433.getKey()); + oprot.writeBinary(_iter433.getValue()); } } } @@ -39476,15 +40422,15 @@ public class Hbase { } if (incoming.get(3)) { { - org.apache.thrift.protocol.TMap _map424 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map424.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key425; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val426; - for (int _i427 = 0; _i427 < _map424.size; ++_i427) + org.apache.thrift.protocol.TMap _map434 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map434.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key435; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val436; + for (int _i437 = 0; _i437 < _map434.size; ++_i437) { - _key425 = iprot.readBinary(); - _val426 = iprot.readBinary(); - struct.attributes.put(_key425, _val426); + _key435 = iprot.readBinary(); + _val436 = iprot.readBinary(); + struct.attributes.put(_key435, _val436); } } struct.setAttributesIsSet(true); @@ -40642,15 +41588,15 @@ public class Hbase { case 5: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map428 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map428.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key429; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val430; - for (int _i431 = 0; _i431 < _map428.size; ++_i431) + org.apache.thrift.protocol.TMap _map438 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map438.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key439; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val440; + for (int _i441 = 0; _i441 < _map438.size; ++_i441) { - _key429 = iprot.readBinary(); - _val430 = iprot.readBinary(); - struct.attributes.put(_key429, _val430); + _key439 = iprot.readBinary(); + _val440 = iprot.readBinary(); + struct.attributes.put(_key439, _val440); } iprot.readMapEnd(); } @@ -40696,10 +41642,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter432 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter442 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter432.getKey()); - oprot.writeBinary(_iter432.getValue()); + oprot.writeBinary(_iter442.getKey()); + oprot.writeBinary(_iter442.getValue()); } oprot.writeMapEnd(); } @@ -40754,10 +41700,10 @@ public class Hbase { if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter433 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter443 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter433.getKey()); - oprot.writeBinary(_iter433.getValue()); + oprot.writeBinary(_iter443.getKey()); + oprot.writeBinary(_iter443.getValue()); } } } @@ -40785,15 +41731,15 @@ public class Hbase { } if (incoming.get(4)) { { - org.apache.thrift.protocol.TMap _map434 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map434.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key435; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val436; - for (int _i437 = 0; _i437 < _map434.size; ++_i437) + org.apache.thrift.protocol.TMap _map444 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map444.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key445; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val446; + for (int _i447 = 0; _i447 < _map444.size; ++_i447) { - _key435 = iprot.readBinary(); - _val436 = iprot.readBinary(); - struct.attributes.put(_key435, _val436); + _key445 = iprot.readBinary(); + _val446 = iprot.readBinary(); + struct.attributes.put(_key445, _val446); } } struct.setAttributesIsSet(true); @@ -41737,15 +42683,15 @@ public class Hbase { case 3: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map438 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map438.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key439; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val440; - for (int _i441 = 0; _i441 < _map438.size; ++_i441) + org.apache.thrift.protocol.TMap _map448 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map448.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key449; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val450; + for (int _i451 = 0; _i451 < _map448.size; ++_i451) { - _key439 = iprot.readBinary(); - _val440 = iprot.readBinary(); - struct.attributes.put(_key439, _val440); + _key449 = iprot.readBinary(); + _val450 = iprot.readBinary(); + struct.attributes.put(_key449, _val450); } iprot.readMapEnd(); } @@ -41783,10 +42729,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter442 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter452 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter442.getKey()); - oprot.writeBinary(_iter442.getValue()); + oprot.writeBinary(_iter452.getKey()); + oprot.writeBinary(_iter452.getValue()); } oprot.writeMapEnd(); } @@ -41829,10 +42775,10 @@ public class Hbase { if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter443 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter453 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter443.getKey()); - oprot.writeBinary(_iter443.getValue()); + oprot.writeBinary(_iter453.getKey()); + oprot.writeBinary(_iter453.getValue()); } } } @@ -41852,15 +42798,15 @@ public class Hbase { } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map444 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map444.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key445; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val446; - for (int _i447 = 0; _i447 < _map444.size; ++_i447) + org.apache.thrift.protocol.TMap _map454 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map454.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key455; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val456; + for (int _i457 = 0; _i457 < _map454.size; ++_i457) { - _key445 = iprot.readBinary(); - _val446 = iprot.readBinary(); - struct.attributes.put(_key445, _val446); + _key455 = iprot.readBinary(); + _val456 = iprot.readBinary(); + struct.attributes.put(_key455, _val456); } } struct.setAttributesIsSet(true); @@ -43319,14 +44265,14 @@ public class Hbase { case 1: // INCREMENTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list448 = iprot.readListBegin(); - struct.increments = new java.util.ArrayList(_list448.size); - @org.apache.thrift.annotation.Nullable TIncrement _elem449; - for (int _i450 = 0; _i450 < _list448.size; ++_i450) + org.apache.thrift.protocol.TList _list458 = iprot.readListBegin(); + struct.increments = new java.util.ArrayList(_list458.size); + @org.apache.thrift.annotation.Nullable TIncrement _elem459; + for (int _i460 = 0; _i460 < _list458.size; ++_i460) { - _elem449 = new TIncrement(); - _elem449.read(iprot); - struct.increments.add(_elem449); + _elem459 = new TIncrement(); + _elem459.read(iprot); + struct.increments.add(_elem459); } iprot.readListEnd(); } @@ -43354,9 +44300,9 @@ public class Hbase { oprot.writeFieldBegin(INCREMENTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.increments.size())); - for (TIncrement _iter451 : struct.increments) + for (TIncrement _iter461 : struct.increments) { - _iter451.write(oprot); + _iter461.write(oprot); } oprot.writeListEnd(); } @@ -43387,9 +44333,9 @@ public class Hbase { if (struct.isSetIncrements()) { { oprot.writeI32(struct.increments.size()); - for (TIncrement _iter452 : struct.increments) + for (TIncrement _iter462 : struct.increments) { - _iter452.write(oprot); + _iter462.write(oprot); } } } @@ -43401,14 +44347,14 @@ public class Hbase { java.util.BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list453 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.increments = new java.util.ArrayList(_list453.size); - @org.apache.thrift.annotation.Nullable TIncrement _elem454; - for (int _i455 = 0; _i455 < _list453.size; ++_i455) + org.apache.thrift.protocol.TList _list463 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.increments = new java.util.ArrayList(_list463.size); + @org.apache.thrift.annotation.Nullable TIncrement _elem464; + for (int _i465 = 0; _i465 < _list463.size; ++_i465) { - _elem454 = new TIncrement(); - _elem454.read(iprot); - struct.increments.add(_elem454); + _elem464 = new TIncrement(); + _elem464.read(iprot); + struct.increments.add(_elem464); } } struct.setIncrementsIsSet(true); @@ -44451,15 +45397,15 @@ public class Hbase { case 4: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map456 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map456.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key457; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val458; - for (int _i459 = 0; _i459 < _map456.size; ++_i459) + org.apache.thrift.protocol.TMap _map466 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map466.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key467; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val468; + for (int _i469 = 0; _i469 < _map466.size; ++_i469) { - _key457 = iprot.readBinary(); - _val458 = iprot.readBinary(); - struct.attributes.put(_key457, _val458); + _key467 = iprot.readBinary(); + _val468 = iprot.readBinary(); + struct.attributes.put(_key467, _val468); } iprot.readMapEnd(); } @@ -44500,10 +45446,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter460 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter470 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter460.getKey()); - oprot.writeBinary(_iter460.getValue()); + oprot.writeBinary(_iter470.getKey()); + oprot.writeBinary(_iter470.getValue()); } oprot.writeMapEnd(); } @@ -44552,10 +45498,10 @@ public class Hbase { if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter461 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter471 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter461.getKey()); - oprot.writeBinary(_iter461.getValue()); + oprot.writeBinary(_iter471.getKey()); + oprot.writeBinary(_iter471.getValue()); } } } @@ -44579,15 +45525,15 @@ public class Hbase { } if (incoming.get(3)) { { - org.apache.thrift.protocol.TMap _map462 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map462.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key463; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val464; - for (int _i465 = 0; _i465 < _map462.size; ++_i465) + org.apache.thrift.protocol.TMap _map472 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map472.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key473; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val474; + for (int _i475 = 0; _i475 < _map472.size; ++_i475) { - _key463 = iprot.readBinary(); - _val464 = iprot.readBinary(); - struct.attributes.put(_key463, _val464); + _key473 = iprot.readBinary(); + _val474 = iprot.readBinary(); + struct.attributes.put(_key473, _val474); } } struct.setAttributesIsSet(true); @@ -45522,15 +46468,15 @@ public class Hbase { case 3: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map466 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map466.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key467; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val468; - for (int _i469 = 0; _i469 < _map466.size; ++_i469) + org.apache.thrift.protocol.TMap _map476 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map476.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key477; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val478; + for (int _i479 = 0; _i479 < _map476.size; ++_i479) { - _key467 = iprot.readBinary(); - _val468 = iprot.readBinary(); - struct.attributes.put(_key467, _val468); + _key477 = iprot.readBinary(); + _val478 = iprot.readBinary(); + struct.attributes.put(_key477, _val478); } iprot.readMapEnd(); } @@ -45568,10 +46514,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter470 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter480 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter470.getKey()); - oprot.writeBinary(_iter470.getValue()); + oprot.writeBinary(_iter480.getKey()); + oprot.writeBinary(_iter480.getValue()); } oprot.writeMapEnd(); } @@ -45614,10 +46560,10 @@ public class Hbase { if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter471 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter481 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter471.getKey()); - oprot.writeBinary(_iter471.getValue()); + oprot.writeBinary(_iter481.getKey()); + oprot.writeBinary(_iter481.getValue()); } } } @@ -45638,15 +46584,15 @@ public class Hbase { } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map472 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map472.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key473; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val474; - for (int _i475 = 0; _i475 < _map472.size; ++_i475) + org.apache.thrift.protocol.TMap _map482 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map482.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key483; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val484; + for (int _i485 = 0; _i485 < _map482.size; ++_i485) { - _key473 = iprot.readBinary(); - _val474 = iprot.readBinary(); - struct.attributes.put(_key473, _val474); + _key483 = iprot.readBinary(); + _val484 = iprot.readBinary(); + struct.attributes.put(_key483, _val484); } } struct.setAttributesIsSet(true); @@ -46819,13 +47765,13 @@ public class Hbase { case 3: // COLUMNS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list476 = iprot.readListBegin(); - struct.columns = new java.util.ArrayList(_list476.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem477; - for (int _i478 = 0; _i478 < _list476.size; ++_i478) + org.apache.thrift.protocol.TList _list486 = iprot.readListBegin(); + struct.columns = new java.util.ArrayList(_list486.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem487; + for (int _i488 = 0; _i488 < _list486.size; ++_i488) { - _elem477 = iprot.readBinary(); - struct.columns.add(_elem477); + _elem487 = iprot.readBinary(); + struct.columns.add(_elem487); } iprot.readListEnd(); } @@ -46837,15 +47783,15 @@ public class Hbase { case 4: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map479 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map479.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key480; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val481; - for (int _i482 = 0; _i482 < _map479.size; ++_i482) + org.apache.thrift.protocol.TMap _map489 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map489.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key490; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val491; + for (int _i492 = 0; _i492 < _map489.size; ++_i492) { - _key480 = iprot.readBinary(); - _val481 = iprot.readBinary(); - struct.attributes.put(_key480, _val481); + _key490 = iprot.readBinary(); + _val491 = iprot.readBinary(); + struct.attributes.put(_key490, _val491); } iprot.readMapEnd(); } @@ -46883,9 +47829,9 @@ public class Hbase { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size())); - for (java.nio.ByteBuffer _iter483 : struct.columns) + for (java.nio.ByteBuffer _iter493 : struct.columns) { - oprot.writeBinary(_iter483); + oprot.writeBinary(_iter493); } oprot.writeListEnd(); } @@ -46895,10 +47841,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter484 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter494 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter484.getKey()); - oprot.writeBinary(_iter484.getValue()); + oprot.writeBinary(_iter494.getKey()); + oprot.writeBinary(_iter494.getValue()); } oprot.writeMapEnd(); } @@ -46944,19 +47890,19 @@ public class Hbase { if (struct.isSetColumns()) { { oprot.writeI32(struct.columns.size()); - for (java.nio.ByteBuffer _iter485 : struct.columns) + for (java.nio.ByteBuffer _iter495 : struct.columns) { - oprot.writeBinary(_iter485); + oprot.writeBinary(_iter495); } } } if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter486 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter496 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter486.getKey()); - oprot.writeBinary(_iter486.getValue()); + oprot.writeBinary(_iter496.getKey()); + oprot.writeBinary(_iter496.getValue()); } } } @@ -46976,28 +47922,28 @@ public class Hbase { } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list487 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.columns = new java.util.ArrayList(_list487.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem488; - for (int _i489 = 0; _i489 < _list487.size; ++_i489) + org.apache.thrift.protocol.TList _list497 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.columns = new java.util.ArrayList(_list497.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem498; + for (int _i499 = 0; _i499 < _list497.size; ++_i499) { - _elem488 = iprot.readBinary(); - struct.columns.add(_elem488); + _elem498 = iprot.readBinary(); + struct.columns.add(_elem498); } } struct.setColumnsIsSet(true); } if (incoming.get(3)) { { - org.apache.thrift.protocol.TMap _map490 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map490.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key491; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val492; - for (int _i493 = 0; _i493 < _map490.size; ++_i493) + org.apache.thrift.protocol.TMap _map500 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map500.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key501; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val502; + for (int _i503 = 0; _i503 < _map500.size; ++_i503) { - _key491 = iprot.readBinary(); - _val492 = iprot.readBinary(); - struct.attributes.put(_key491, _val492); + _key501 = iprot.readBinary(); + _val502 = iprot.readBinary(); + struct.attributes.put(_key501, _val502); } } struct.setAttributesIsSet(true); @@ -48289,13 +49235,13 @@ public class Hbase { case 4: // COLUMNS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list494 = iprot.readListBegin(); - struct.columns = new java.util.ArrayList(_list494.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem495; - for (int _i496 = 0; _i496 < _list494.size; ++_i496) + org.apache.thrift.protocol.TList _list504 = iprot.readListBegin(); + struct.columns = new java.util.ArrayList(_list504.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem505; + for (int _i506 = 0; _i506 < _list504.size; ++_i506) { - _elem495 = iprot.readBinary(); - struct.columns.add(_elem495); + _elem505 = iprot.readBinary(); + struct.columns.add(_elem505); } iprot.readListEnd(); } @@ -48307,15 +49253,15 @@ public class Hbase { case 5: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map497 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map497.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key498; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val499; - for (int _i500 = 0; _i500 < _map497.size; ++_i500) + org.apache.thrift.protocol.TMap _map507 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map507.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key508; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val509; + for (int _i510 = 0; _i510 < _map507.size; ++_i510) { - _key498 = iprot.readBinary(); - _val499 = iprot.readBinary(); - struct.attributes.put(_key498, _val499); + _key508 = iprot.readBinary(); + _val509 = iprot.readBinary(); + struct.attributes.put(_key508, _val509); } iprot.readMapEnd(); } @@ -48358,9 +49304,9 @@ public class Hbase { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size())); - for (java.nio.ByteBuffer _iter501 : struct.columns) + for (java.nio.ByteBuffer _iter511 : struct.columns) { - oprot.writeBinary(_iter501); + oprot.writeBinary(_iter511); } oprot.writeListEnd(); } @@ -48370,10 +49316,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter502 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter512 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter502.getKey()); - oprot.writeBinary(_iter502.getValue()); + oprot.writeBinary(_iter512.getKey()); + oprot.writeBinary(_iter512.getValue()); } oprot.writeMapEnd(); } @@ -48425,19 +49371,19 @@ public class Hbase { if (struct.isSetColumns()) { { oprot.writeI32(struct.columns.size()); - for (java.nio.ByteBuffer _iter503 : struct.columns) + for (java.nio.ByteBuffer _iter513 : struct.columns) { - oprot.writeBinary(_iter503); + oprot.writeBinary(_iter513); } } } if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter504 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter514 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter504.getKey()); - oprot.writeBinary(_iter504.getValue()); + oprot.writeBinary(_iter514.getKey()); + oprot.writeBinary(_iter514.getValue()); } } } @@ -48461,28 +49407,28 @@ public class Hbase { } if (incoming.get(3)) { { - org.apache.thrift.protocol.TList _list505 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.columns = new java.util.ArrayList(_list505.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem506; - for (int _i507 = 0; _i507 < _list505.size; ++_i507) + org.apache.thrift.protocol.TList _list515 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.columns = new java.util.ArrayList(_list515.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem516; + for (int _i517 = 0; _i517 < _list515.size; ++_i517) { - _elem506 = iprot.readBinary(); - struct.columns.add(_elem506); + _elem516 = iprot.readBinary(); + struct.columns.add(_elem516); } } struct.setColumnsIsSet(true); } if (incoming.get(4)) { { - org.apache.thrift.protocol.TMap _map508 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map508.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key509; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val510; - for (int _i511 = 0; _i511 < _map508.size; ++_i511) + org.apache.thrift.protocol.TMap _map518 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map518.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key519; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val520; + for (int _i521 = 0; _i521 < _map518.size; ++_i521) { - _key509 = iprot.readBinary(); - _val510 = iprot.readBinary(); - struct.attributes.put(_key509, _val510); + _key519 = iprot.readBinary(); + _val520 = iprot.readBinary(); + struct.attributes.put(_key519, _val520); } } struct.setAttributesIsSet(true); @@ -49643,13 +50589,13 @@ public class Hbase { case 3: // COLUMNS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list512 = iprot.readListBegin(); - struct.columns = new java.util.ArrayList(_list512.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem513; - for (int _i514 = 0; _i514 < _list512.size; ++_i514) + org.apache.thrift.protocol.TList _list522 = iprot.readListBegin(); + struct.columns = new java.util.ArrayList(_list522.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem523; + for (int _i524 = 0; _i524 < _list522.size; ++_i524) { - _elem513 = iprot.readBinary(); - struct.columns.add(_elem513); + _elem523 = iprot.readBinary(); + struct.columns.add(_elem523); } iprot.readListEnd(); } @@ -49661,15 +50607,15 @@ public class Hbase { case 4: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map515 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map515.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key516; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val517; - for (int _i518 = 0; _i518 < _map515.size; ++_i518) + org.apache.thrift.protocol.TMap _map525 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map525.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key526; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val527; + for (int _i528 = 0; _i528 < _map525.size; ++_i528) { - _key516 = iprot.readBinary(); - _val517 = iprot.readBinary(); - struct.attributes.put(_key516, _val517); + _key526 = iprot.readBinary(); + _val527 = iprot.readBinary(); + struct.attributes.put(_key526, _val527); } iprot.readMapEnd(); } @@ -49707,9 +50653,9 @@ public class Hbase { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size())); - for (java.nio.ByteBuffer _iter519 : struct.columns) + for (java.nio.ByteBuffer _iter529 : struct.columns) { - oprot.writeBinary(_iter519); + oprot.writeBinary(_iter529); } oprot.writeListEnd(); } @@ -49719,10 +50665,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter520 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter530 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter520.getKey()); - oprot.writeBinary(_iter520.getValue()); + oprot.writeBinary(_iter530.getKey()); + oprot.writeBinary(_iter530.getValue()); } oprot.writeMapEnd(); } @@ -49768,19 +50714,19 @@ public class Hbase { if (struct.isSetColumns()) { { oprot.writeI32(struct.columns.size()); - for (java.nio.ByteBuffer _iter521 : struct.columns) + for (java.nio.ByteBuffer _iter531 : struct.columns) { - oprot.writeBinary(_iter521); + oprot.writeBinary(_iter531); } } } if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter522 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter532 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter522.getKey()); - oprot.writeBinary(_iter522.getValue()); + oprot.writeBinary(_iter532.getKey()); + oprot.writeBinary(_iter532.getValue()); } } } @@ -49800,28 +50746,28 @@ public class Hbase { } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list523 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.columns = new java.util.ArrayList(_list523.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem524; - for (int _i525 = 0; _i525 < _list523.size; ++_i525) + org.apache.thrift.protocol.TList _list533 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.columns = new java.util.ArrayList(_list533.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem534; + for (int _i535 = 0; _i535 < _list533.size; ++_i535) { - _elem524 = iprot.readBinary(); - struct.columns.add(_elem524); + _elem534 = iprot.readBinary(); + struct.columns.add(_elem534); } } struct.setColumnsIsSet(true); } if (incoming.get(3)) { { - org.apache.thrift.protocol.TMap _map526 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map526.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key527; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val528; - for (int _i529 = 0; _i529 < _map526.size; ++_i529) + org.apache.thrift.protocol.TMap _map536 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map536.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key537; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val538; + for (int _i539 = 0; _i539 < _map536.size; ++_i539) { - _key527 = iprot.readBinary(); - _val528 = iprot.readBinary(); - struct.attributes.put(_key527, _val528); + _key537 = iprot.readBinary(); + _val538 = iprot.readBinary(); + struct.attributes.put(_key537, _val538); } } struct.setAttributesIsSet(true); @@ -51085,13 +52031,13 @@ public class Hbase { case 3: // COLUMNS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list530 = iprot.readListBegin(); - struct.columns = new java.util.ArrayList(_list530.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem531; - for (int _i532 = 0; _i532 < _list530.size; ++_i532) + org.apache.thrift.protocol.TList _list540 = iprot.readListBegin(); + struct.columns = new java.util.ArrayList(_list540.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem541; + for (int _i542 = 0; _i542 < _list540.size; ++_i542) { - _elem531 = iprot.readBinary(); - struct.columns.add(_elem531); + _elem541 = iprot.readBinary(); + struct.columns.add(_elem541); } iprot.readListEnd(); } @@ -51111,15 +52057,15 @@ public class Hbase { case 5: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map533 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map533.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key534; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val535; - for (int _i536 = 0; _i536 < _map533.size; ++_i536) + org.apache.thrift.protocol.TMap _map543 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map543.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key544; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val545; + for (int _i546 = 0; _i546 < _map543.size; ++_i546) { - _key534 = iprot.readBinary(); - _val535 = iprot.readBinary(); - struct.attributes.put(_key534, _val535); + _key544 = iprot.readBinary(); + _val545 = iprot.readBinary(); + struct.attributes.put(_key544, _val545); } iprot.readMapEnd(); } @@ -51157,9 +52103,9 @@ public class Hbase { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size())); - for (java.nio.ByteBuffer _iter537 : struct.columns) + for (java.nio.ByteBuffer _iter547 : struct.columns) { - oprot.writeBinary(_iter537); + oprot.writeBinary(_iter547); } oprot.writeListEnd(); } @@ -51172,10 +52118,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter538 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter548 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter538.getKey()); - oprot.writeBinary(_iter538.getValue()); + oprot.writeBinary(_iter548.getKey()); + oprot.writeBinary(_iter548.getValue()); } oprot.writeMapEnd(); } @@ -51224,9 +52170,9 @@ public class Hbase { if (struct.isSetColumns()) { { oprot.writeI32(struct.columns.size()); - for (java.nio.ByteBuffer _iter539 : struct.columns) + for (java.nio.ByteBuffer _iter549 : struct.columns) { - oprot.writeBinary(_iter539); + oprot.writeBinary(_iter549); } } } @@ -51236,10 +52182,10 @@ public class Hbase { if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter540 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter550 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter540.getKey()); - oprot.writeBinary(_iter540.getValue()); + oprot.writeBinary(_iter550.getKey()); + oprot.writeBinary(_iter550.getValue()); } } } @@ -51259,13 +52205,13 @@ public class Hbase { } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list541 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.columns = new java.util.ArrayList(_list541.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem542; - for (int _i543 = 0; _i543 < _list541.size; ++_i543) + org.apache.thrift.protocol.TList _list551 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.columns = new java.util.ArrayList(_list551.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem552; + for (int _i553 = 0; _i553 < _list551.size; ++_i553) { - _elem542 = iprot.readBinary(); - struct.columns.add(_elem542); + _elem552 = iprot.readBinary(); + struct.columns.add(_elem552); } } struct.setColumnsIsSet(true); @@ -51276,15 +52222,15 @@ public class Hbase { } if (incoming.get(4)) { { - org.apache.thrift.protocol.TMap _map544 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map544.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key545; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val546; - for (int _i547 = 0; _i547 < _map544.size; ++_i547) + org.apache.thrift.protocol.TMap _map554 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map554.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key555; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val556; + for (int _i557 = 0; _i557 < _map554.size; ++_i557) { - _key545 = iprot.readBinary(); - _val546 = iprot.readBinary(); - struct.attributes.put(_key545, _val546); + _key555 = iprot.readBinary(); + _val556 = iprot.readBinary(); + struct.attributes.put(_key555, _val556); } } struct.setAttributesIsSet(true); @@ -52667,13 +53613,13 @@ public class Hbase { case 4: // COLUMNS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list548 = iprot.readListBegin(); - struct.columns = new java.util.ArrayList(_list548.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem549; - for (int _i550 = 0; _i550 < _list548.size; ++_i550) + org.apache.thrift.protocol.TList _list558 = iprot.readListBegin(); + struct.columns = new java.util.ArrayList(_list558.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem559; + for (int _i560 = 0; _i560 < _list558.size; ++_i560) { - _elem549 = iprot.readBinary(); - struct.columns.add(_elem549); + _elem559 = iprot.readBinary(); + struct.columns.add(_elem559); } iprot.readListEnd(); } @@ -52693,15 +53639,15 @@ public class Hbase { case 6: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map551 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map551.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key552; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val553; - for (int _i554 = 0; _i554 < _map551.size; ++_i554) + org.apache.thrift.protocol.TMap _map561 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map561.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key562; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val563; + for (int _i564 = 0; _i564 < _map561.size; ++_i564) { - _key552 = iprot.readBinary(); - _val553 = iprot.readBinary(); - struct.attributes.put(_key552, _val553); + _key562 = iprot.readBinary(); + _val563 = iprot.readBinary(); + struct.attributes.put(_key562, _val563); } iprot.readMapEnd(); } @@ -52744,9 +53690,9 @@ public class Hbase { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size())); - for (java.nio.ByteBuffer _iter555 : struct.columns) + for (java.nio.ByteBuffer _iter565 : struct.columns) { - oprot.writeBinary(_iter555); + oprot.writeBinary(_iter565); } oprot.writeListEnd(); } @@ -52759,10 +53705,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter556 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter566 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter556.getKey()); - oprot.writeBinary(_iter556.getValue()); + oprot.writeBinary(_iter566.getKey()); + oprot.writeBinary(_iter566.getValue()); } oprot.writeMapEnd(); } @@ -52817,9 +53763,9 @@ public class Hbase { if (struct.isSetColumns()) { { oprot.writeI32(struct.columns.size()); - for (java.nio.ByteBuffer _iter557 : struct.columns) + for (java.nio.ByteBuffer _iter567 : struct.columns) { - oprot.writeBinary(_iter557); + oprot.writeBinary(_iter567); } } } @@ -52829,10 +53775,10 @@ public class Hbase { if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter558 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter568 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter558.getKey()); - oprot.writeBinary(_iter558.getValue()); + oprot.writeBinary(_iter568.getKey()); + oprot.writeBinary(_iter568.getValue()); } } } @@ -52856,13 +53802,13 @@ public class Hbase { } if (incoming.get(3)) { { - org.apache.thrift.protocol.TList _list559 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.columns = new java.util.ArrayList(_list559.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem560; - for (int _i561 = 0; _i561 < _list559.size; ++_i561) + org.apache.thrift.protocol.TList _list569 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.columns = new java.util.ArrayList(_list569.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem570; + for (int _i571 = 0; _i571 < _list569.size; ++_i571) { - _elem560 = iprot.readBinary(); - struct.columns.add(_elem560); + _elem570 = iprot.readBinary(); + struct.columns.add(_elem570); } } struct.setColumnsIsSet(true); @@ -52873,15 +53819,15 @@ public class Hbase { } if (incoming.get(5)) { { - org.apache.thrift.protocol.TMap _map562 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map562.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key563; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val564; - for (int _i565 = 0; _i565 < _map562.size; ++_i565) + org.apache.thrift.protocol.TMap _map572 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map572.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key573; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val574; + for (int _i575 = 0; _i575 < _map572.size; ++_i575) { - _key563 = iprot.readBinary(); - _val564 = iprot.readBinary(); - struct.attributes.put(_key563, _val564); + _key573 = iprot.readBinary(); + _val574 = iprot.readBinary(); + struct.attributes.put(_key573, _val574); } } struct.setAttributesIsSet(true); @@ -54217,14 +55163,14 @@ public class Hbase { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list566 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list566.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem567; - for (int _i568 = 0; _i568 < _list566.size; ++_i568) + org.apache.thrift.protocol.TList _list576 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list576.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem577; + for (int _i578 = 0; _i578 < _list576.size; ++_i578) { - _elem567 = new TRowResult(); - _elem567.read(iprot); - struct.success.add(_elem567); + _elem577 = new TRowResult(); + _elem577.read(iprot); + struct.success.add(_elem577); } iprot.readListEnd(); } @@ -54270,9 +55216,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TRowResult _iter569 : struct.success) + for (TRowResult _iter579 : struct.success) { - _iter569.write(oprot); + _iter579.write(oprot); } oprot.writeListEnd(); } @@ -54319,9 +55265,9 @@ public class Hbase { if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TRowResult _iter570 : struct.success) + for (TRowResult _iter580 : struct.success) { - _iter570.write(oprot); + _iter580.write(oprot); } } } @@ -54339,14 +55285,14 @@ public class Hbase { java.util.BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list571 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list571.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem572; - for (int _i573 = 0; _i573 < _list571.size; ++_i573) + org.apache.thrift.protocol.TList _list581 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list581.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem582; + for (int _i583 = 0; _i583 < _list581.size; ++_i583) { - _elem572 = new TRowResult(); - _elem572.read(iprot); - struct.success.add(_elem572); + _elem582 = new TRowResult(); + _elem582.read(iprot); + struct.success.add(_elem582); } } struct.setSuccessIsSet(true); @@ -55331,14 +56277,14 @@ public class Hbase { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list574 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list574.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem575; - for (int _i576 = 0; _i576 < _list574.size; ++_i576) + org.apache.thrift.protocol.TList _list584 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list584.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem585; + for (int _i586 = 0; _i586 < _list584.size; ++_i586) { - _elem575 = new TRowResult(); - _elem575.read(iprot); - struct.success.add(_elem575); + _elem585 = new TRowResult(); + _elem585.read(iprot); + struct.success.add(_elem585); } iprot.readListEnd(); } @@ -55384,9 +56330,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TRowResult _iter577 : struct.success) + for (TRowResult _iter587 : struct.success) { - _iter577.write(oprot); + _iter587.write(oprot); } oprot.writeListEnd(); } @@ -55433,9 +56379,9 @@ public class Hbase { if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TRowResult _iter578 : struct.success) + for (TRowResult _iter588 : struct.success) { - _iter578.write(oprot); + _iter588.write(oprot); } } } @@ -55453,14 +56399,14 @@ public class Hbase { java.util.BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list579 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list579.size); - @org.apache.thrift.annotation.Nullable TRowResult _elem580; - for (int _i581 = 0; _i581 < _list579.size; ++_i581) + org.apache.thrift.protocol.TList _list589 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list589.size); + @org.apache.thrift.annotation.Nullable TRowResult _elem590; + for (int _i591 = 0; _i591 < _list589.size; ++_i591) { - _elem580 = new TRowResult(); - _elem580.read(iprot); - struct.success.add(_elem580); + _elem590 = new TRowResult(); + _elem590.read(iprot); + struct.success.add(_elem590); } } struct.setSuccessIsSet(true); @@ -57978,14 +58924,14 @@ public class Hbase { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list582 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list582.size); - @org.apache.thrift.annotation.Nullable TCell _elem583; - for (int _i584 = 0; _i584 < _list582.size; ++_i584) + org.apache.thrift.protocol.TList _list592 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list592.size); + @org.apache.thrift.annotation.Nullable TCell _elem593; + for (int _i594 = 0; _i594 < _list592.size; ++_i594) { - _elem583 = new TCell(); - _elem583.read(iprot); - struct.success.add(_elem583); + _elem593 = new TCell(); + _elem593.read(iprot); + struct.success.add(_elem593); } iprot.readListEnd(); } @@ -58022,9 +58968,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TCell _iter585 : struct.success) + for (TCell _iter595 : struct.success) { - _iter585.write(oprot); + _iter595.write(oprot); } oprot.writeListEnd(); } @@ -58063,9 +59009,9 @@ public class Hbase { if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TCell _iter586 : struct.success) + for (TCell _iter596 : struct.success) { - _iter586.write(oprot); + _iter596.write(oprot); } } } @@ -58080,14 +59026,14 @@ public class Hbase { java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list587 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list587.size); - @org.apache.thrift.annotation.Nullable TCell _elem588; - for (int _i589 = 0; _i589 < _list587.size; ++_i589) + org.apache.thrift.protocol.TList _list597 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list597.size); + @org.apache.thrift.annotation.Nullable TCell _elem598; + for (int _i599 = 0; _i599 < _list597.size; ++_i599) { - _elem588 = new TCell(); - _elem588.read(iprot); - struct.success.add(_elem588); + _elem598 = new TCell(); + _elem598.read(iprot); + struct.success.add(_elem598); } } struct.setSuccessIsSet(true); @@ -59013,15 +59959,15 @@ public class Hbase { case 7: // ATTRIBUTES if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map590 = iprot.readMapBegin(); - struct.attributes = new java.util.HashMap(2*_map590.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key591; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val592; - for (int _i593 = 0; _i593 < _map590.size; ++_i593) + org.apache.thrift.protocol.TMap _map600 = iprot.readMapBegin(); + struct.attributes = new java.util.HashMap(2*_map600.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key601; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val602; + for (int _i603 = 0; _i603 < _map600.size; ++_i603) { - _key591 = iprot.readBinary(); - _val592 = iprot.readBinary(); - struct.attributes.put(_key591, _val592); + _key601 = iprot.readBinary(); + _val602 = iprot.readBinary(); + struct.attributes.put(_key601, _val602); } iprot.readMapEnd(); } @@ -59074,10 +60020,10 @@ public class Hbase { oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); - for (java.util.Map.Entry _iter594 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter604 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter594.getKey()); - oprot.writeBinary(_iter594.getValue()); + oprot.writeBinary(_iter604.getKey()); + oprot.writeBinary(_iter604.getValue()); } oprot.writeMapEnd(); } @@ -59138,10 +60084,10 @@ public class Hbase { if (struct.isSetAttributes()) { { oprot.writeI32(struct.attributes.size()); - for (java.util.Map.Entry _iter595 : struct.attributes.entrySet()) + for (java.util.Map.Entry _iter605 : struct.attributes.entrySet()) { - oprot.writeBinary(_iter595.getKey()); - oprot.writeBinary(_iter595.getValue()); + oprot.writeBinary(_iter605.getKey()); + oprot.writeBinary(_iter605.getValue()); } } } @@ -59174,15 +60120,15 @@ public class Hbase { } if (incoming.get(5)) { { - org.apache.thrift.protocol.TMap _map596 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.attributes = new java.util.HashMap(2*_map596.size); - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key597; - @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val598; - for (int _i599 = 0; _i599 < _map596.size; ++_i599) + org.apache.thrift.protocol.TMap _map606 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.attributes = new java.util.HashMap(2*_map606.size); + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key607; + @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val608; + for (int _i609 = 0; _i609 < _map606.size; ++_i609) { - _key597 = iprot.readBinary(); - _val598 = iprot.readBinary(); - struct.attributes.put(_key597, _val598); + _key607 = iprot.readBinary(); + _val608 = iprot.readBinary(); + struct.attributes.put(_key607, _val608); } } struct.setAttributesIsSet(true); diff --git a/hbase-thrift/src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift b/hbase-thrift/src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift index d5cc76a39ee..9f596a63ff2 100644 --- a/hbase-thrift/src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift +++ b/hbase-thrift/src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift @@ -245,6 +245,14 @@ service Hbase { list getTableNames() throws (1:IOError io) + /** + * List all the userspace tables and their enabled or disabled flags. + * + * @return list of tables with is enabled flags + */ + map getTableNamesWithIsTableEnabled() + throws (1:IOError io) + /** * List all the column families assoicated with a table. * diff --git a/hbase-thrift/src/test/java/org/apache/hadoop/hbase/thrift/TestThriftServer.java b/hbase-thrift/src/test/java/org/apache/hadoop/hbase/thrift/TestThriftServer.java index af422a4e996..64957f22191 100644 --- a/hbase-thrift/src/test/java/org/apache/hadoop/hbase/thrift/TestThriftServer.java +++ b/hbase-thrift/src/test/java/org/apache/hadoop/hbase/thrift/TestThriftServer.java @@ -32,6 +32,7 @@ import java.util.Collection; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.concurrent.atomic.AtomicInteger; import java.util.stream.Collectors; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.CompatibilityFactory; @@ -738,6 +739,35 @@ public class TestThriftServer { } } + @Test + public void testGetTableNamesWithStatus() throws Exception{ + ThriftHBaseServiceHandler handler = + new ThriftHBaseServiceHandler(UTIL.getConfiguration(), + UserProvider.instantiate(UTIL.getConfiguration())); + + createTestTables(handler); + + assertEquals(2, handler.getTableNamesWithIsTableEnabled().size()); + assertEquals(2, countTablesByStatus(true, handler)); + handler.disableTable(tableBname); + assertEquals(1, countTablesByStatus(true, handler)); + assertEquals(1, countTablesByStatus(false, handler)); + assertEquals(2, handler.getTableNamesWithIsTableEnabled().size()); + handler.enableTable(tableBname); + assertEquals(2, countTablesByStatus(true, handler)); + + dropTestTables(handler); + } + + private static int countTablesByStatus(Boolean isEnabled, Hbase.Iface handler) throws Exception { + AtomicInteger counter = new AtomicInteger(0); + handler.getTableNamesWithIsTableEnabled().forEach( + (table, tableStatus) -> { + if (tableStatus.equals(isEnabled)) counter.getAndIncrement(); + }); + return counter.get(); + } + @Test public void testMetricsWithException() throws Exception { String rowkey = "row1";