Return-Path: X-Original-To: apmail-accumulo-commits-archive@www.apache.org Delivered-To: apmail-accumulo-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id C09299F43 for ; Thu, 24 May 2012 03:05:53 +0000 (UTC) Received: (qmail 67393 invoked by uid 500); 24 May 2012 03:05:53 -0000 Delivered-To: apmail-accumulo-commits-archive@accumulo.apache.org Received: (qmail 67334 invoked by uid 500); 24 May 2012 03:05:52 -0000 Mailing-List: contact commits-help@accumulo.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@accumulo.apache.org Delivered-To: mailing list commits@accumulo.apache.org Received: (qmail 67305 invoked by uid 99); 24 May 2012 03:05:51 -0000 Received: from nike.apache.org (HELO nike.apache.org) (192.87.106.230) by apache.org (qpsmtpd/0.29) with ESMTP; Thu, 24 May 2012 03:05:51 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=5.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Thu, 24 May 2012 03:05:38 +0000 Received: from eris.apache.org (localhost [127.0.0.1]) by eris.apache.org (Postfix) with ESMTP id 487332388978 for ; Thu, 24 May 2012 03:05:16 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r1342122 [1/2] - in /accumulo/trunk: core/src/main/java/org/apache/accumulo/core/client/admin/ core/src/main/java/org/apache/accumulo/core/client/mock/ core/src/main/java/org/apache/accumulo/core/iterators/ core/src/main/java/org/apache/acc... Date: Thu, 24 May 2012 03:05:15 -0000 To: commits@accumulo.apache.org From: kturner@apache.org X-Mailer: svnmailer-1.0.8-patched Message-Id: <20120524030516.487332388978@eris.apache.org> Author: kturner Date: Thu May 24 03:05:14 2012 New Revision: 1342122 URL: http://svn.apache.org/viewvc?rev=1342122&view=rev Log: ACCUMULO-420 initial checking of per compaction iterators Added: accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/IteratorConfig.java accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/TIteratorSetting.java Modified: accumulo/trunk/core/src/main/java/org/apache/accumulo/core/client/admin/TableOperations.java accumulo/trunk/core/src/main/java/org/apache/accumulo/core/client/admin/TableOperationsImpl.java accumulo/trunk/core/src/main/java/org/apache/accumulo/core/client/mock/MockTableOperations.java accumulo/trunk/core/src/main/java/org/apache/accumulo/core/iterators/IteratorUtil.java accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/MutationLogger.java accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/TabletClientService.java accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/TabletMutations.java accumulo/trunk/core/src/main/thrift/tabletserver.thrift accumulo/trunk/core/src/test/java/org/apache/accumulo/core/client/admin/TableOperationsHelperTest.java accumulo/trunk/server/src/main/java/org/apache/accumulo/server/master/Master.java accumulo/trunk/server/src/main/java/org/apache/accumulo/server/master/tableOps/CompactRange.java accumulo/trunk/server/src/main/java/org/apache/accumulo/server/tabletserver/Compactor.java accumulo/trunk/server/src/main/java/org/apache/accumulo/server/tabletserver/Tablet.java accumulo/trunk/server/src/main/java/org/apache/accumulo/server/tabletserver/TabletServer.java Modified: accumulo/trunk/core/src/main/java/org/apache/accumulo/core/client/admin/TableOperations.java URL: http://svn.apache.org/viewvc/accumulo/trunk/core/src/main/java/org/apache/accumulo/core/client/admin/TableOperations.java?rev=1342122&r1=1342121&r2=1342122&view=diff ============================================================================== --- accumulo/trunk/core/src/main/java/org/apache/accumulo/core/client/admin/TableOperations.java (original) +++ accumulo/trunk/core/src/main/java/org/apache/accumulo/core/client/admin/TableOperations.java Thu May 24 03:05:14 2012 @@ -19,6 +19,7 @@ package org.apache.accumulo.core.client. import java.io.IOException; import java.util.Collection; import java.util.EnumSet; +import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; @@ -195,6 +196,25 @@ public interface TableOperations { AccumuloException; /** + * Starts a full major compaction of the tablets in the range (start, end]. The compaction is preformed even for tablets that have only one file. + * + * @param tableName + * the table to compact + * @param start + * first tablet to be compacted contains the row after this row, null means the first tablet in table + * @param end + * last tablet to be merged contains this row, null means the last tablet in table + * @param iterators + * A set of iterators that will be applied to each tablet compacted + * @param flush + * when true, table memory is flushed before compaction starts + * @param wait + * when true, the call will not return until compactions are finished + */ + public void compact(String tableName, Text start, Text end, List iterators, boolean flush, boolean wait) throws AccumuloSecurityException, + TableNotFoundException, AccumuloException; + + /** * Delete a table * * @param tableName Modified: accumulo/trunk/core/src/main/java/org/apache/accumulo/core/client/admin/TableOperationsImpl.java URL: http://svn.apache.org/viewvc/accumulo/trunk/core/src/main/java/org/apache/accumulo/core/client/admin/TableOperationsImpl.java?rev=1342122&r1=1342121&r2=1342122&view=diff ============================================================================== --- accumulo/trunk/core/src/main/java/org/apache/accumulo/core/client/admin/TableOperationsImpl.java (original) +++ accumulo/trunk/core/src/main/java/org/apache/accumulo/core/client/admin/TableOperationsImpl.java Thu May 24 03:05:14 2012 @@ -42,6 +42,7 @@ import org.apache.accumulo.core.Constant import org.apache.accumulo.core.client.AccumuloException; import org.apache.accumulo.core.client.AccumuloSecurityException; import org.apache.accumulo.core.client.Instance; +import org.apache.accumulo.core.client.IteratorSetting; import org.apache.accumulo.core.client.Scanner; import org.apache.accumulo.core.client.TableDeletedException; import org.apache.accumulo.core.client.TableExistsException; @@ -684,6 +685,11 @@ public class TableOperationsImpl extends public void compact(String tableName, Text start, Text end, boolean flush, boolean wait) throws AccumuloSecurityException, TableNotFoundException, AccumuloException { + compact(tableName, start, end, new ArrayList(), flush, wait); + } + + public void compact(String tableName, Text start, Text end, List iterators, boolean flush, boolean wait) throws AccumuloSecurityException, + TableNotFoundException, AccumuloException { ArgumentChecker.notNull(tableName); ByteBuffer EMPTY = ByteBuffer.allocate(0); @@ -693,7 +699,8 @@ public class TableOperationsImpl extends _flush(tableId, start, end, true); List args = Arrays.asList(ByteBuffer.wrap(tableId.getBytes()), start == null ? EMPTY : TextUtil.getByteBuffer(start), end == null ? EMPTY - : TextUtil.getByteBuffer(end)); + : TextUtil.getByteBuffer(end), ByteBuffer.wrap(IteratorUtil.encodeIteratorSettings(iterators))); + Map opts = new HashMap(); try { doTableOperation(TableOperation.COMPACT, args, opts, wait); Modified: accumulo/trunk/core/src/main/java/org/apache/accumulo/core/client/mock/MockTableOperations.java URL: http://svn.apache.org/viewvc/accumulo/trunk/core/src/main/java/org/apache/accumulo/core/client/mock/MockTableOperations.java?rev=1342122&r1=1342121&r2=1342122&view=diff ============================================================================== --- accumulo/trunk/core/src/main/java/org/apache/accumulo/core/client/mock/MockTableOperations.java (original) +++ accumulo/trunk/core/src/main/java/org/apache/accumulo/core/client/mock/MockTableOperations.java Thu May 24 03:05:14 2012 @@ -20,6 +20,7 @@ import java.io.IOException; import java.util.Collection; import java.util.Collections; import java.util.HashMap; +import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; @@ -29,6 +30,7 @@ import java.util.TreeSet; import org.apache.accumulo.core.Constants; import org.apache.accumulo.core.client.AccumuloException; import org.apache.accumulo.core.client.AccumuloSecurityException; +import org.apache.accumulo.core.client.IteratorSetting; import org.apache.accumulo.core.client.TableExistsException; import org.apache.accumulo.core.client.TableNotFoundException; import org.apache.accumulo.core.client.admin.FindMax; @@ -200,6 +202,12 @@ public class MockTableOperations extends } @Override + public void compact(String tableName, Text start, Text end, List iterators, boolean flush, boolean wait) throws AccumuloSecurityException, + TableNotFoundException, AccumuloException { + throw new NotImplementedException(); + } + + @Override public void clone(String srcTableName, String newTableName, boolean flush, Map propertiesToSet, Set propertiesToExclude) throws AccumuloException, AccumuloSecurityException, TableNotFoundException, TableExistsException { throw new NotImplementedException(); Modified: accumulo/trunk/core/src/main/java/org/apache/accumulo/core/iterators/IteratorUtil.java URL: http://svn.apache.org/viewvc/accumulo/trunk/core/src/main/java/org/apache/accumulo/core/iterators/IteratorUtil.java?rev=1342122&r1=1342121&r2=1342122&view=diff ============================================================================== --- accumulo/trunk/core/src/main/java/org/apache/accumulo/core/iterators/IteratorUtil.java (original) +++ accumulo/trunk/core/src/main/java/org/apache/accumulo/core/iterators/IteratorUtil.java Thu May 24 03:05:14 2012 @@ -27,6 +27,7 @@ import java.util.Map; import java.util.Map.Entry; import java.util.TreeMap; +import org.apache.accumulo.core.client.IteratorSetting; import org.apache.accumulo.core.conf.AccumuloConfiguration; import org.apache.accumulo.core.conf.Property; import org.apache.accumulo.core.data.Key; @@ -35,10 +36,16 @@ import org.apache.accumulo.core.data.Ran import org.apache.accumulo.core.data.thrift.IterInfo; import org.apache.accumulo.core.iterators.system.SynchronizedIterator; import org.apache.accumulo.core.iterators.user.VersioningIterator; +import org.apache.accumulo.core.tabletserver.thrift.IteratorConfig; +import org.apache.accumulo.core.tabletserver.thrift.TIteratorSetting; import org.apache.accumulo.start.classloader.AccumuloClassLoader; import org.apache.hadoop.io.Writable; import org.apache.hadoop.io.WritableComparable; import org.apache.log4j.Logger; +import org.apache.thrift.TDeserializer; +import org.apache.thrift.TException; +import org.apache.thrift.TSerializer; +import org.apache.thrift.protocol.TBinaryProtocol; public class IteratorUtil { private static final Logger log = Logger.getLogger(IteratorUtil.class); @@ -155,6 +162,21 @@ public class IteratorUtil { } public static ,V extends Writable> SortedKeyValueIterator loadIterators(IteratorScope scope, + SortedKeyValueIterator source, KeyExtent extent, AccumuloConfiguration conf, List iterators, IteratorEnvironment env) + throws IOException { + + List ssiList = new ArrayList(); + Map> ssio = new HashMap>(); + + for (IteratorSetting is : iterators) { + ssiList.add(new IterInfo(is.getPriority(), is.getIteratorClass(), is.getName())); + ssio.put(is.getName(), is.getOptions()); + } + + return loadIterators(scope, source, extent, conf, ssiList, ssio, env, true); + } + + public static ,V extends Writable> SortedKeyValueIterator loadIterators(IteratorScope scope, SortedKeyValueIterator source, KeyExtent extent, AccumuloConfiguration conf, List ssiList, Map> ssio, IteratorEnvironment env) throws IOException { return loadIterators(scope, source, extent, conf, ssiList, ssio, env, true); @@ -243,4 +265,57 @@ public class IteratorUtil { return seekRange; } + + public static TIteratorSetting toTIteratorSetting(IteratorSetting is) { + return new TIteratorSetting(is.getPriority(), is.getName(), is.getIteratorClass(), is.getOptions()); + } + + public static IteratorSetting toIteratorSetting(TIteratorSetting tis) { + return new IteratorSetting(tis.getPriority(), tis.getName(), tis.getIteratorClass(), tis.getProperties()); + } + + public static IteratorConfig toIteratorConfig(List iterators) { + ArrayList tisList = new ArrayList(); + + for (IteratorSetting iteratorSetting : iterators) { + tisList.add(toTIteratorSetting(iteratorSetting)); + } + + return new IteratorConfig(tisList); + } + + public static List toIteratorSettings(IteratorConfig ic) { + List ret = new ArrayList(); + for (TIteratorSetting tIteratorSetting : ic.getIterators()) { + ret.add(toIteratorSetting(tIteratorSetting)); + } + + return ret; + } + + public static byte[] encodeIteratorSettings(IteratorConfig iterators) { + TSerializer tser = new TSerializer(new TBinaryProtocol.Factory()); + + try { + return tser.serialize(iterators); + } catch (TException e) { + throw new RuntimeException(e); + } + } + + public static byte[] encodeIteratorSettings(List iterators) { + return encodeIteratorSettings(toIteratorConfig(iterators)); + } + + + public static List decodeIteratorSettings(byte[] enc) { + TDeserializer tdser = new TDeserializer(new TBinaryProtocol.Factory()); + IteratorConfig ic = new IteratorConfig(); + try { + tdser.deserialize(ic, enc); + } catch (TException e) { + throw new RuntimeException(e); + } + return toIteratorSettings(ic); + } } Added: accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/IteratorConfig.java URL: http://svn.apache.org/viewvc/accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/IteratorConfig.java?rev=1342122&view=auto ============================================================================== --- accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/IteratorConfig.java (added) +++ accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/IteratorConfig.java Thu May 24 03:05:14 2012 @@ -0,0 +1,357 @@ +/** + * Autogenerated by Thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + */ +package org.apache.accumulo.core.tabletserver.thrift; + +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings("all") public class IteratorConfig implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("IteratorConfig"); + + private static final org.apache.thrift.protocol.TField ITERATORS_FIELD_DESC = new org.apache.thrift.protocol.TField("iterators", org.apache.thrift.protocol.TType.LIST, (short)1); + + public List iterators; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ITERATORS((short)1, "iterators"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // ITERATORS + return ITERATORS; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.ITERATORS, new org.apache.thrift.meta_data.FieldMetaData("iterators", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIteratorSetting.class)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(IteratorConfig.class, metaDataMap); + } + + public IteratorConfig() { + } + + public IteratorConfig( + List iterators) + { + this(); + this.iterators = iterators; + } + + /** + * Performs a deep copy on other. + */ + public IteratorConfig(IteratorConfig other) { + if (other.isSetIterators()) { + List __this__iterators = new ArrayList(); + for (TIteratorSetting other_element : other.iterators) { + __this__iterators.add(new TIteratorSetting(other_element)); + } + this.iterators = __this__iterators; + } + } + + public IteratorConfig deepCopy() { + return new IteratorConfig(this); + } + + @Override + public void clear() { + this.iterators = null; + } + + public int getIteratorsSize() { + return (this.iterators == null) ? 0 : this.iterators.size(); + } + + public java.util.Iterator getIteratorsIterator() { + return (this.iterators == null) ? null : this.iterators.iterator(); + } + + public void addToIterators(TIteratorSetting elem) { + if (this.iterators == null) { + this.iterators = new ArrayList(); + } + this.iterators.add(elem); + } + + public List getIterators() { + return this.iterators; + } + + public IteratorConfig setIterators(List iterators) { + this.iterators = iterators; + return this; + } + + public void unsetIterators() { + this.iterators = null; + } + + /** Returns true if field iterators is set (has been assigned a value) and false otherwise */ + public boolean isSetIterators() { + return this.iterators != null; + } + + public void setIteratorsIsSet(boolean value) { + if (!value) { + this.iterators = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case ITERATORS: + if (value == null) { + unsetIterators(); + } else { + setIterators((List)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case ITERATORS: + return getIterators(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case ITERATORS: + return isSetIterators(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof IteratorConfig) + return this.equals((IteratorConfig)that); + return false; + } + + public boolean equals(IteratorConfig that) { + if (that == null) + return false; + + boolean this_present_iterators = true && this.isSetIterators(); + boolean that_present_iterators = true && that.isSetIterators(); + if (this_present_iterators || that_present_iterators) { + if (!(this_present_iterators && that_present_iterators)) + return false; + if (!this.iterators.equals(that.iterators)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(IteratorConfig other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + IteratorConfig typedOther = (IteratorConfig)other; + + lastComparison = Boolean.valueOf(isSetIterators()).compareTo(typedOther.isSetIterators()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetIterators()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.iterators, typedOther.iterators); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField field; + iprot.readStructBegin(); + while (true) + { + field = iprot.readFieldBegin(); + if (field.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (field.id) { + case 1: // ITERATORS + if (field.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list27 = iprot.readListBegin(); + this.iterators = new ArrayList(_list27.size); + for (int _i28 = 0; _i28 < _list27.size; ++_i28) + { + TIteratorSetting _elem29; + _elem29 = new TIteratorSetting(); + _elem29.read(iprot); + this.iterators.add(_elem29); + } + iprot.readListEnd(); + } + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + + // check for required fields of primitive type, which can't be checked in the validate method + validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (this.iterators != null) { + oprot.writeFieldBegin(ITERATORS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.iterators.size())); + for (TIteratorSetting _iter30 : this.iterators) + { + _iter30.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("IteratorConfig("); + boolean first = true; + + sb.append("iterators:"); + if (this.iterators == null) { + sb.append("null"); + } else { + sb.append(this.iterators); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + 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); + } + } + +} + Modified: accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/MutationLogger.java URL: http://svn.apache.org/viewvc/accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/MutationLogger.java?rev=1342122&r1=1342121&r2=1342122&view=diff ============================================================================== --- accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/MutationLogger.java (original) +++ accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/MutationLogger.java Thu May 24 03:05:14 2012 @@ -4961,14 +4961,14 @@ import org.slf4j.LoggerFactory; case 2: // MUTATIONS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list109 = iprot.readListBegin(); - this.mutations = new ArrayList(_list109.size); - for (int _i110 = 0; _i110 < _list109.size; ++_i110) + org.apache.thrift.protocol.TList _list118 = iprot.readListBegin(); + this.mutations = new ArrayList(_list118.size); + for (int _i119 = 0; _i119 < _list118.size; ++_i119) { - TabletMutations _elem111; - _elem111 = new TabletMutations(); - _elem111.read(iprot); - this.mutations.add(_elem111); + TabletMutations _elem120; + _elem120 = new TabletMutations(); + _elem120.read(iprot); + this.mutations.add(_elem120); } iprot.readListEnd(); } @@ -4998,9 +4998,9 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(MUTATIONS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.mutations.size())); - for (TabletMutations _iter112 : this.mutations) + for (TabletMutations _iter121 : this.mutations) { - _iter112.write(oprot); + _iter121.write(oprot); } oprot.writeListEnd(); } @@ -10035,13 +10035,13 @@ import org.slf4j.LoggerFactory; case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list113 = iprot.readListBegin(); - this.success = new ArrayList(_list113.size); - for (int _i114 = 0; _i114 < _list113.size; ++_i114) + org.apache.thrift.protocol.TList _list122 = iprot.readListBegin(); + this.success = new ArrayList(_list122.size); + for (int _i123 = 0; _i123 < _list122.size; ++_i123) { - String _elem115; - _elem115 = iprot.readString(); - this.success.add(_elem115); + String _elem124; + _elem124 = iprot.readString(); + this.success.add(_elem124); } iprot.readListEnd(); } @@ -10075,9 +10075,9 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size())); - for (String _iter116 : this.success) + for (String _iter125 : this.success) { - oprot.writeString(_iter116); + oprot.writeString(_iter125); } oprot.writeListEnd(); } @@ -10542,13 +10542,13 @@ import org.slf4j.LoggerFactory; case 2: // FILES if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list117 = iprot.readListBegin(); - this.files = new ArrayList(_list117.size); - for (int _i118 = 0; _i118 < _list117.size; ++_i118) + org.apache.thrift.protocol.TList _list126 = iprot.readListBegin(); + this.files = new ArrayList(_list126.size); + for (int _i127 = 0; _i127 < _list126.size; ++_i127) { - String _elem119; - _elem119 = iprot.readString(); - this.files.add(_elem119); + String _elem128; + _elem128 = iprot.readString(); + this.files.add(_elem128); } iprot.readListEnd(); } @@ -10580,9 +10580,9 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(FILES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.files.size())); - for (String _iter120 : this.files) + for (String _iter129 : this.files) { - oprot.writeString(_iter120); + oprot.writeString(_iter129); } oprot.writeListEnd(); } Added: accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/TIteratorSetting.java URL: http://svn.apache.org/viewvc/accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/TIteratorSetting.java?rev=1342122&view=auto ============================================================================== --- accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/TIteratorSetting.java (added) +++ accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/TIteratorSetting.java Thu May 24 03:05:14 2012 @@ -0,0 +1,631 @@ +/** + * Autogenerated by Thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + */ +package org.apache.accumulo.core.tabletserver.thrift; + +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings("all") public class TIteratorSetting implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TIteratorSetting"); + + private static final org.apache.thrift.protocol.TField PRIORITY_FIELD_DESC = new org.apache.thrift.protocol.TField("priority", org.apache.thrift.protocol.TType.I32, (short)1); + private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField ITERATOR_CLASS_FIELD_DESC = new org.apache.thrift.protocol.TField("iteratorClass", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField PROPERTIES_FIELD_DESC = new org.apache.thrift.protocol.TField("properties", org.apache.thrift.protocol.TType.MAP, (short)4); + + public int priority; + public String name; + public String iteratorClass; + public Map properties; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PRIORITY((short)1, "priority"), + NAME((short)2, "name"), + ITERATOR_CLASS((short)3, "iteratorClass"), + PROPERTIES((short)4, "properties"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // PRIORITY + return PRIORITY; + case 2: // NAME + return NAME; + case 3: // ITERATOR_CLASS + return ITERATOR_CLASS; + case 4: // PROPERTIES + return PROPERTIES; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __PRIORITY_ISSET_ID = 0; + private BitSet __isset_bit_vector = new BitSet(1); + + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PRIORITY, new org.apache.thrift.meta_data.FieldMetaData("priority", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.ITERATOR_CLASS, new org.apache.thrift.meta_data.FieldMetaData("iteratorClass", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PROPERTIES, new org.apache.thrift.meta_data.FieldMetaData("properties", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TIteratorSetting.class, metaDataMap); + } + + public TIteratorSetting() { + } + + public TIteratorSetting( + int priority, + String name, + String iteratorClass, + Map properties) + { + this(); + this.priority = priority; + setPriorityIsSet(true); + this.name = name; + this.iteratorClass = iteratorClass; + this.properties = properties; + } + + /** + * Performs a deep copy on other. + */ + public TIteratorSetting(TIteratorSetting other) { + __isset_bit_vector.clear(); + __isset_bit_vector.or(other.__isset_bit_vector); + this.priority = other.priority; + if (other.isSetName()) { + this.name = other.name; + } + if (other.isSetIteratorClass()) { + this.iteratorClass = other.iteratorClass; + } + if (other.isSetProperties()) { + Map __this__properties = new HashMap(); + for (Map.Entry other_element : other.properties.entrySet()) { + + String other_element_key = other_element.getKey(); + String other_element_value = other_element.getValue(); + + String __this__properties_copy_key = other_element_key; + + String __this__properties_copy_value = other_element_value; + + __this__properties.put(__this__properties_copy_key, __this__properties_copy_value); + } + this.properties = __this__properties; + } + } + + public TIteratorSetting deepCopy() { + return new TIteratorSetting(this); + } + + @Override + public void clear() { + setPriorityIsSet(false); + this.priority = 0; + this.name = null; + this.iteratorClass = null; + this.properties = null; + } + + public int getPriority() { + return this.priority; + } + + public TIteratorSetting setPriority(int priority) { + this.priority = priority; + setPriorityIsSet(true); + return this; + } + + public void unsetPriority() { + __isset_bit_vector.clear(__PRIORITY_ISSET_ID); + } + + /** Returns true if field priority is set (has been assigned a value) and false otherwise */ + public boolean isSetPriority() { + return __isset_bit_vector.get(__PRIORITY_ISSET_ID); + } + + public void setPriorityIsSet(boolean value) { + __isset_bit_vector.set(__PRIORITY_ISSET_ID, value); + } + + public String getName() { + return this.name; + } + + public TIteratorSetting setName(String name) { + this.name = name; + return this; + } + + public void unsetName() { + this.name = null; + } + + /** Returns true if field name is set (has been assigned a value) and false otherwise */ + public boolean isSetName() { + return this.name != null; + } + + public void setNameIsSet(boolean value) { + if (!value) { + this.name = null; + } + } + + public String getIteratorClass() { + return this.iteratorClass; + } + + public TIteratorSetting setIteratorClass(String iteratorClass) { + this.iteratorClass = iteratorClass; + return this; + } + + public void unsetIteratorClass() { + this.iteratorClass = null; + } + + /** Returns true if field iteratorClass is set (has been assigned a value) and false otherwise */ + public boolean isSetIteratorClass() { + return this.iteratorClass != null; + } + + public void setIteratorClassIsSet(boolean value) { + if (!value) { + this.iteratorClass = null; + } + } + + public int getPropertiesSize() { + return (this.properties == null) ? 0 : this.properties.size(); + } + + public void putToProperties(String key, String val) { + if (this.properties == null) { + this.properties = new HashMap(); + } + this.properties.put(key, val); + } + + public Map getProperties() { + return this.properties; + } + + public TIteratorSetting setProperties(Map properties) { + this.properties = properties; + return this; + } + + public void unsetProperties() { + this.properties = null; + } + + /** Returns true if field properties is set (has been assigned a value) and false otherwise */ + public boolean isSetProperties() { + return this.properties != null; + } + + public void setPropertiesIsSet(boolean value) { + if (!value) { + this.properties = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PRIORITY: + if (value == null) { + unsetPriority(); + } else { + setPriority((Integer)value); + } + break; + + case NAME: + if (value == null) { + unsetName(); + } else { + setName((String)value); + } + break; + + case ITERATOR_CLASS: + if (value == null) { + unsetIteratorClass(); + } else { + setIteratorClass((String)value); + } + break; + + case PROPERTIES: + if (value == null) { + unsetProperties(); + } else { + setProperties((Map)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case PRIORITY: + return new Integer(getPriority()); + + case NAME: + return getName(); + + case ITERATOR_CLASS: + return getIteratorClass(); + + case PROPERTIES: + return getProperties(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case PRIORITY: + return isSetPriority(); + case NAME: + return isSetName(); + case ITERATOR_CLASS: + return isSetIteratorClass(); + case PROPERTIES: + return isSetProperties(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof TIteratorSetting) + return this.equals((TIteratorSetting)that); + return false; + } + + public boolean equals(TIteratorSetting that) { + if (that == null) + return false; + + boolean this_present_priority = true; + boolean that_present_priority = true; + if (this_present_priority || that_present_priority) { + if (!(this_present_priority && that_present_priority)) + return false; + if (this.priority != that.priority) + return false; + } + + boolean this_present_name = true && this.isSetName(); + boolean that_present_name = true && that.isSetName(); + if (this_present_name || that_present_name) { + if (!(this_present_name && that_present_name)) + return false; + if (!this.name.equals(that.name)) + return false; + } + + boolean this_present_iteratorClass = true && this.isSetIteratorClass(); + boolean that_present_iteratorClass = true && that.isSetIteratorClass(); + if (this_present_iteratorClass || that_present_iteratorClass) { + if (!(this_present_iteratorClass && that_present_iteratorClass)) + return false; + if (!this.iteratorClass.equals(that.iteratorClass)) + return false; + } + + boolean this_present_properties = true && this.isSetProperties(); + boolean that_present_properties = true && that.isSetProperties(); + if (this_present_properties || that_present_properties) { + if (!(this_present_properties && that_present_properties)) + return false; + if (!this.properties.equals(that.properties)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(TIteratorSetting other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + TIteratorSetting typedOther = (TIteratorSetting)other; + + lastComparison = Boolean.valueOf(isSetPriority()).compareTo(typedOther.isSetPriority()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPriority()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.priority, typedOther.priority); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetName()).compareTo(typedOther.isSetName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, typedOther.name); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetIteratorClass()).compareTo(typedOther.isSetIteratorClass()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetIteratorClass()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.iteratorClass, typedOther.iteratorClass); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetProperties()).compareTo(typedOther.isSetProperties()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetProperties()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.properties, typedOther.properties); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField field; + iprot.readStructBegin(); + while (true) + { + field = iprot.readFieldBegin(); + if (field.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (field.id) { + case 1: // PRIORITY + if (field.type == org.apache.thrift.protocol.TType.I32) { + this.priority = iprot.readI32(); + setPriorityIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 2: // NAME + if (field.type == org.apache.thrift.protocol.TType.STRING) { + this.name = iprot.readString(); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 3: // ITERATOR_CLASS + if (field.type == org.apache.thrift.protocol.TType.STRING) { + this.iteratorClass = iprot.readString(); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 4: // PROPERTIES + if (field.type == org.apache.thrift.protocol.TType.MAP) { + { + org.apache.thrift.protocol.TMap _map22 = iprot.readMapBegin(); + this.properties = new HashMap(2*_map22.size); + for (int _i23 = 0; _i23 < _map22.size; ++_i23) + { + String _key24; + String _val25; + _key24 = iprot.readString(); + _val25 = iprot.readString(); + this.properties.put(_key24, _val25); + } + iprot.readMapEnd(); + } + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + + // check for required fields of primitive type, which can't be checked in the validate method + validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(PRIORITY_FIELD_DESC); + oprot.writeI32(this.priority); + oprot.writeFieldEnd(); + if (this.name != null) { + oprot.writeFieldBegin(NAME_FIELD_DESC); + oprot.writeString(this.name); + oprot.writeFieldEnd(); + } + if (this.iteratorClass != null) { + oprot.writeFieldBegin(ITERATOR_CLASS_FIELD_DESC); + oprot.writeString(this.iteratorClass); + oprot.writeFieldEnd(); + } + if (this.properties != null) { + oprot.writeFieldBegin(PROPERTIES_FIELD_DESC); + { + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.properties.size())); + for (Map.Entry _iter26 : this.properties.entrySet()) + { + oprot.writeString(_iter26.getKey()); + oprot.writeString(_iter26.getValue()); + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("TIteratorSetting("); + boolean first = true; + + sb.append("priority:"); + sb.append(this.priority); + first = false; + if (!first) sb.append(", "); + sb.append("name:"); + if (this.name == null) { + sb.append("null"); + } else { + sb.append(this.name); + } + first = false; + if (!first) sb.append(", "); + sb.append("iteratorClass:"); + if (this.iteratorClass == null) { + sb.append("null"); + } else { + sb.append(this.iteratorClass); + } + first = false; + if (!first) sb.append(", "); + sb.append("properties:"); + if (this.properties == null) { + sb.append("null"); + } else { + sb.append(this.properties); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bit_vector = new BitSet(1); + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + +} + Modified: accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/TabletClientService.java URL: http://svn.apache.org/viewvc/accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/TabletClientService.java?rev=1342122&r1=1342121&r2=1342122&view=diff ============================================================================== --- accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/TabletClientService.java (original) +++ accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/TabletClientService.java Thu May 24 03:05:14 2012 @@ -3891,14 +3891,14 @@ import org.slf4j.LoggerFactory; case 4: // COLUMNS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list26 = iprot.readListBegin(); - this.columns = new ArrayList(_list26.size); - for (int _i27 = 0; _i27 < _list26.size; ++_i27) + org.apache.thrift.protocol.TList _list35 = iprot.readListBegin(); + this.columns = new ArrayList(_list35.size); + for (int _i36 = 0; _i36 < _list35.size; ++_i36) { - org.apache.accumulo.core.data.thrift.TColumn _elem28; - _elem28 = new org.apache.accumulo.core.data.thrift.TColumn(); - _elem28.read(iprot); - this.columns.add(_elem28); + org.apache.accumulo.core.data.thrift.TColumn _elem37; + _elem37 = new org.apache.accumulo.core.data.thrift.TColumn(); + _elem37.read(iprot); + this.columns.add(_elem37); } iprot.readListEnd(); } @@ -3917,14 +3917,14 @@ import org.slf4j.LoggerFactory; case 6: // SSI_LIST if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list29 = iprot.readListBegin(); - this.ssiList = new ArrayList(_list29.size); - for (int _i30 = 0; _i30 < _list29.size; ++_i30) + org.apache.thrift.protocol.TList _list38 = iprot.readListBegin(); + this.ssiList = new ArrayList(_list38.size); + for (int _i39 = 0; _i39 < _list38.size; ++_i39) { - org.apache.accumulo.core.data.thrift.IterInfo _elem31; - _elem31 = new org.apache.accumulo.core.data.thrift.IterInfo(); - _elem31.read(iprot); - this.ssiList.add(_elem31); + org.apache.accumulo.core.data.thrift.IterInfo _elem40; + _elem40 = new org.apache.accumulo.core.data.thrift.IterInfo(); + _elem40.read(iprot); + this.ssiList.add(_elem40); } iprot.readListEnd(); } @@ -3935,27 +3935,27 @@ import org.slf4j.LoggerFactory; case 7: // SSIO if (field.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map32 = iprot.readMapBegin(); - this.ssio = new HashMap>(2*_map32.size); - for (int _i33 = 0; _i33 < _map32.size; ++_i33) + org.apache.thrift.protocol.TMap _map41 = iprot.readMapBegin(); + this.ssio = new HashMap>(2*_map41.size); + for (int _i42 = 0; _i42 < _map41.size; ++_i42) { - String _key34; - Map _val35; - _key34 = iprot.readString(); + String _key43; + Map _val44; + _key43 = iprot.readString(); { - org.apache.thrift.protocol.TMap _map36 = iprot.readMapBegin(); - _val35 = new HashMap(2*_map36.size); - for (int _i37 = 0; _i37 < _map36.size; ++_i37) + org.apache.thrift.protocol.TMap _map45 = iprot.readMapBegin(); + _val44 = new HashMap(2*_map45.size); + for (int _i46 = 0; _i46 < _map45.size; ++_i46) { - String _key38; - String _val39; - _key38 = iprot.readString(); - _val39 = iprot.readString(); - _val35.put(_key38, _val39); + String _key47; + String _val48; + _key47 = iprot.readString(); + _val48 = iprot.readString(); + _val44.put(_key47, _val48); } iprot.readMapEnd(); } - this.ssio.put(_key34, _val35); + this.ssio.put(_key43, _val44); } iprot.readMapEnd(); } @@ -3966,13 +3966,13 @@ import org.slf4j.LoggerFactory; case 8: // AUTHORIZATIONS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list40 = iprot.readListBegin(); - this.authorizations = new ArrayList(_list40.size); - for (int _i41 = 0; _i41 < _list40.size; ++_i41) + org.apache.thrift.protocol.TList _list49 = iprot.readListBegin(); + this.authorizations = new ArrayList(_list49.size); + for (int _i50 = 0; _i50 < _list49.size; ++_i50) { - ByteBuffer _elem42; - _elem42 = iprot.readBinary(); - this.authorizations.add(_elem42); + ByteBuffer _elem51; + _elem51 = iprot.readBinary(); + this.authorizations.add(_elem51); } iprot.readListEnd(); } @@ -4030,9 +4030,9 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.columns.size())); - for (org.apache.accumulo.core.data.thrift.TColumn _iter43 : this.columns) + for (org.apache.accumulo.core.data.thrift.TColumn _iter52 : this.columns) { - _iter43.write(oprot); + _iter52.write(oprot); } oprot.writeListEnd(); } @@ -4045,9 +4045,9 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(SSI_LIST_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.ssiList.size())); - for (org.apache.accumulo.core.data.thrift.IterInfo _iter44 : this.ssiList) + for (org.apache.accumulo.core.data.thrift.IterInfo _iter53 : this.ssiList) { - _iter44.write(oprot); + _iter53.write(oprot); } oprot.writeListEnd(); } @@ -4057,15 +4057,15 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(SSIO_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.MAP, this.ssio.size())); - for (Map.Entry> _iter45 : this.ssio.entrySet()) + for (Map.Entry> _iter54 : this.ssio.entrySet()) { - oprot.writeString(_iter45.getKey()); + oprot.writeString(_iter54.getKey()); { - oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter45.getValue().size())); - for (Map.Entry _iter46 : _iter45.getValue().entrySet()) + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter54.getValue().size())); + for (Map.Entry _iter55 : _iter54.getValue().entrySet()) { - oprot.writeString(_iter46.getKey()); - oprot.writeString(_iter46.getValue()); + oprot.writeString(_iter55.getKey()); + oprot.writeString(_iter55.getValue()); } oprot.writeMapEnd(); } @@ -4078,9 +4078,9 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(AUTHORIZATIONS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.authorizations.size())); - for (ByteBuffer _iter47 : this.authorizations) + for (ByteBuffer _iter56 : this.authorizations) { - oprot.writeBinary(_iter47); + oprot.writeBinary(_iter56); } oprot.writeListEnd(); } @@ -6955,27 +6955,27 @@ import org.slf4j.LoggerFactory; case 2: // BATCH if (field.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map48 = iprot.readMapBegin(); - this.batch = new HashMap>(2*_map48.size); - for (int _i49 = 0; _i49 < _map48.size; ++_i49) + org.apache.thrift.protocol.TMap _map57 = iprot.readMapBegin(); + this.batch = new HashMap>(2*_map57.size); + for (int _i58 = 0; _i58 < _map57.size; ++_i58) { - org.apache.accumulo.core.data.thrift.TKeyExtent _key50; - List _val51; - _key50 = new org.apache.accumulo.core.data.thrift.TKeyExtent(); - _key50.read(iprot); + org.apache.accumulo.core.data.thrift.TKeyExtent _key59; + List _val60; + _key59 = new org.apache.accumulo.core.data.thrift.TKeyExtent(); + _key59.read(iprot); { - org.apache.thrift.protocol.TList _list52 = iprot.readListBegin(); - _val51 = new ArrayList(_list52.size); - for (int _i53 = 0; _i53 < _list52.size; ++_i53) + org.apache.thrift.protocol.TList _list61 = iprot.readListBegin(); + _val60 = new ArrayList(_list61.size); + for (int _i62 = 0; _i62 < _list61.size; ++_i62) { - org.apache.accumulo.core.data.thrift.TRange _elem54; - _elem54 = new org.apache.accumulo.core.data.thrift.TRange(); - _elem54.read(iprot); - _val51.add(_elem54); + org.apache.accumulo.core.data.thrift.TRange _elem63; + _elem63 = new org.apache.accumulo.core.data.thrift.TRange(); + _elem63.read(iprot); + _val60.add(_elem63); } iprot.readListEnd(); } - this.batch.put(_key50, _val51); + this.batch.put(_key59, _val60); } iprot.readMapEnd(); } @@ -6986,14 +6986,14 @@ import org.slf4j.LoggerFactory; case 3: // COLUMNS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list55 = iprot.readListBegin(); - this.columns = new ArrayList(_list55.size); - for (int _i56 = 0; _i56 < _list55.size; ++_i56) + org.apache.thrift.protocol.TList _list64 = iprot.readListBegin(); + this.columns = new ArrayList(_list64.size); + for (int _i65 = 0; _i65 < _list64.size; ++_i65) { - org.apache.accumulo.core.data.thrift.TColumn _elem57; - _elem57 = new org.apache.accumulo.core.data.thrift.TColumn(); - _elem57.read(iprot); - this.columns.add(_elem57); + org.apache.accumulo.core.data.thrift.TColumn _elem66; + _elem66 = new org.apache.accumulo.core.data.thrift.TColumn(); + _elem66.read(iprot); + this.columns.add(_elem66); } iprot.readListEnd(); } @@ -7004,14 +7004,14 @@ import org.slf4j.LoggerFactory; case 4: // SSI_LIST if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list58 = iprot.readListBegin(); - this.ssiList = new ArrayList(_list58.size); - for (int _i59 = 0; _i59 < _list58.size; ++_i59) + org.apache.thrift.protocol.TList _list67 = iprot.readListBegin(); + this.ssiList = new ArrayList(_list67.size); + for (int _i68 = 0; _i68 < _list67.size; ++_i68) { - org.apache.accumulo.core.data.thrift.IterInfo _elem60; - _elem60 = new org.apache.accumulo.core.data.thrift.IterInfo(); - _elem60.read(iprot); - this.ssiList.add(_elem60); + org.apache.accumulo.core.data.thrift.IterInfo _elem69; + _elem69 = new org.apache.accumulo.core.data.thrift.IterInfo(); + _elem69.read(iprot); + this.ssiList.add(_elem69); } iprot.readListEnd(); } @@ -7022,27 +7022,27 @@ import org.slf4j.LoggerFactory; case 5: // SSIO if (field.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map61 = iprot.readMapBegin(); - this.ssio = new HashMap>(2*_map61.size); - for (int _i62 = 0; _i62 < _map61.size; ++_i62) + org.apache.thrift.protocol.TMap _map70 = iprot.readMapBegin(); + this.ssio = new HashMap>(2*_map70.size); + for (int _i71 = 0; _i71 < _map70.size; ++_i71) { - String _key63; - Map _val64; - _key63 = iprot.readString(); + String _key72; + Map _val73; + _key72 = iprot.readString(); { - org.apache.thrift.protocol.TMap _map65 = iprot.readMapBegin(); - _val64 = new HashMap(2*_map65.size); - for (int _i66 = 0; _i66 < _map65.size; ++_i66) + org.apache.thrift.protocol.TMap _map74 = iprot.readMapBegin(); + _val73 = new HashMap(2*_map74.size); + for (int _i75 = 0; _i75 < _map74.size; ++_i75) { - String _key67; - String _val68; - _key67 = iprot.readString(); - _val68 = iprot.readString(); - _val64.put(_key67, _val68); + String _key76; + String _val77; + _key76 = iprot.readString(); + _val77 = iprot.readString(); + _val73.put(_key76, _val77); } iprot.readMapEnd(); } - this.ssio.put(_key63, _val64); + this.ssio.put(_key72, _val73); } iprot.readMapEnd(); } @@ -7053,13 +7053,13 @@ import org.slf4j.LoggerFactory; case 6: // AUTHORIZATIONS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list69 = iprot.readListBegin(); - this.authorizations = new ArrayList(_list69.size); - for (int _i70 = 0; _i70 < _list69.size; ++_i70) + org.apache.thrift.protocol.TList _list78 = iprot.readListBegin(); + this.authorizations = new ArrayList(_list78.size); + for (int _i79 = 0; _i79 < _list78.size; ++_i79) { - ByteBuffer _elem71; - _elem71 = iprot.readBinary(); - this.authorizations.add(_elem71); + ByteBuffer _elem80; + _elem80 = iprot.readBinary(); + this.authorizations.add(_elem80); } iprot.readListEnd(); } @@ -7099,14 +7099,14 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(BATCH_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRUCT, org.apache.thrift.protocol.TType.LIST, this.batch.size())); - for (Map.Entry> _iter72 : this.batch.entrySet()) + for (Map.Entry> _iter81 : this.batch.entrySet()) { - _iter72.getKey().write(oprot); + _iter81.getKey().write(oprot); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter72.getValue().size())); - for (org.apache.accumulo.core.data.thrift.TRange _iter73 : _iter72.getValue()) + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter81.getValue().size())); + for (org.apache.accumulo.core.data.thrift.TRange _iter82 : _iter81.getValue()) { - _iter73.write(oprot); + _iter82.write(oprot); } oprot.writeListEnd(); } @@ -7119,9 +7119,9 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.columns.size())); - for (org.apache.accumulo.core.data.thrift.TColumn _iter74 : this.columns) + for (org.apache.accumulo.core.data.thrift.TColumn _iter83 : this.columns) { - _iter74.write(oprot); + _iter83.write(oprot); } oprot.writeListEnd(); } @@ -7131,9 +7131,9 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(SSI_LIST_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.ssiList.size())); - for (org.apache.accumulo.core.data.thrift.IterInfo _iter75 : this.ssiList) + for (org.apache.accumulo.core.data.thrift.IterInfo _iter84 : this.ssiList) { - _iter75.write(oprot); + _iter84.write(oprot); } oprot.writeListEnd(); } @@ -7143,15 +7143,15 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(SSIO_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.MAP, this.ssio.size())); - for (Map.Entry> _iter76 : this.ssio.entrySet()) + for (Map.Entry> _iter85 : this.ssio.entrySet()) { - oprot.writeString(_iter76.getKey()); + oprot.writeString(_iter85.getKey()); { - oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter76.getValue().size())); - for (Map.Entry _iter77 : _iter76.getValue().entrySet()) + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter85.getValue().size())); + for (Map.Entry _iter86 : _iter85.getValue().entrySet()) { - oprot.writeString(_iter77.getKey()); - oprot.writeString(_iter77.getValue()); + oprot.writeString(_iter86.getKey()); + oprot.writeString(_iter86.getValue()); } oprot.writeMapEnd(); } @@ -7164,9 +7164,9 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(AUTHORIZATIONS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.authorizations.size())); - for (ByteBuffer _iter78 : this.authorizations) + for (ByteBuffer _iter87 : this.authorizations) { - oprot.writeBinary(_iter78); + oprot.writeBinary(_iter87); } oprot.writeListEnd(); } @@ -10377,14 +10377,14 @@ import org.slf4j.LoggerFactory; case 4: // MUTATIONS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list79 = iprot.readListBegin(); - this.mutations = new ArrayList(_list79.size); - for (int _i80 = 0; _i80 < _list79.size; ++_i80) + org.apache.thrift.protocol.TList _list88 = iprot.readListBegin(); + this.mutations = new ArrayList(_list88.size); + for (int _i89 = 0; _i89 < _list88.size; ++_i89) { - org.apache.accumulo.core.data.thrift.TMutation _elem81; - _elem81 = new org.apache.accumulo.core.data.thrift.TMutation(); - _elem81.read(iprot); - this.mutations.add(_elem81); + org.apache.accumulo.core.data.thrift.TMutation _elem90; + _elem90 = new org.apache.accumulo.core.data.thrift.TMutation(); + _elem90.read(iprot); + this.mutations.add(_elem90); } iprot.readListEnd(); } @@ -10424,9 +10424,9 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(MUTATIONS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.mutations.size())); - for (org.apache.accumulo.core.data.thrift.TMutation _iter82 : this.mutations) + for (org.apache.accumulo.core.data.thrift.TMutation _iter91 : this.mutations) { - _iter82.write(oprot); + _iter91.write(oprot); } oprot.writeListEnd(); } @@ -12857,29 +12857,29 @@ import org.slf4j.LoggerFactory; case 2: // FILES if (field.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map83 = iprot.readMapBegin(); - this.files = new HashMap>(2*_map83.size); - for (int _i84 = 0; _i84 < _map83.size; ++_i84) + org.apache.thrift.protocol.TMap _map92 = iprot.readMapBegin(); + this.files = new HashMap>(2*_map92.size); + for (int _i93 = 0; _i93 < _map92.size; ++_i93) { - org.apache.accumulo.core.data.thrift.TKeyExtent _key85; - Map _val86; - _key85 = new org.apache.accumulo.core.data.thrift.TKeyExtent(); - _key85.read(iprot); + org.apache.accumulo.core.data.thrift.TKeyExtent _key94; + Map _val95; + _key94 = new org.apache.accumulo.core.data.thrift.TKeyExtent(); + _key94.read(iprot); { - org.apache.thrift.protocol.TMap _map87 = iprot.readMapBegin(); - _val86 = new HashMap(2*_map87.size); - for (int _i88 = 0; _i88 < _map87.size; ++_i88) + org.apache.thrift.protocol.TMap _map96 = iprot.readMapBegin(); + _val95 = new HashMap(2*_map96.size); + for (int _i97 = 0; _i97 < _map96.size; ++_i97) { - String _key89; - org.apache.accumulo.core.data.thrift.MapFileInfo _val90; - _key89 = iprot.readString(); - _val90 = new org.apache.accumulo.core.data.thrift.MapFileInfo(); - _val90.read(iprot); - _val86.put(_key89, _val90); + String _key98; + org.apache.accumulo.core.data.thrift.MapFileInfo _val99; + _key98 = iprot.readString(); + _val99 = new org.apache.accumulo.core.data.thrift.MapFileInfo(); + _val99.read(iprot); + _val95.put(_key98, _val99); } iprot.readMapEnd(); } - this.files.put(_key85, _val86); + this.files.put(_key94, _val95); } iprot.readMapEnd(); } @@ -12919,15 +12919,15 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(FILES_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRUCT, org.apache.thrift.protocol.TType.MAP, this.files.size())); - for (Map.Entry> _iter91 : this.files.entrySet()) + for (Map.Entry> _iter100 : this.files.entrySet()) { - _iter91.getKey().write(oprot); + _iter100.getKey().write(oprot); { - oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, _iter91.getValue().size())); - for (Map.Entry _iter92 : _iter91.getValue().entrySet()) + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, _iter100.getValue().size())); + for (Map.Entry _iter101 : _iter100.getValue().entrySet()) { - oprot.writeString(_iter92.getKey()); - _iter92.getValue().write(oprot); + oprot.writeString(_iter101.getKey()); + _iter101.getValue().write(oprot); } oprot.writeMapEnd(); } @@ -13335,14 +13335,14 @@ import org.slf4j.LoggerFactory; case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list93 = iprot.readListBegin(); - this.success = new ArrayList(_list93.size); - for (int _i94 = 0; _i94 < _list93.size; ++_i94) + org.apache.thrift.protocol.TList _list102 = iprot.readListBegin(); + this.success = new ArrayList(_list102.size); + for (int _i103 = 0; _i103 < _list102.size; ++_i103) { - org.apache.accumulo.core.data.thrift.TKeyExtent _elem95; - _elem95 = new org.apache.accumulo.core.data.thrift.TKeyExtent(); - _elem95.read(iprot); - this.success.add(_elem95); + org.apache.accumulo.core.data.thrift.TKeyExtent _elem104; + _elem104 = new org.apache.accumulo.core.data.thrift.TKeyExtent(); + _elem104.read(iprot); + this.success.add(_elem104); } iprot.readListEnd(); } @@ -13376,9 +13376,9 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (org.apache.accumulo.core.data.thrift.TKeyExtent _iter96 : this.success) + for (org.apache.accumulo.core.data.thrift.TKeyExtent _iter105 : this.success) { - _iter96.write(oprot); + _iter105.write(oprot); } oprot.writeListEnd(); } @@ -18696,13 +18696,13 @@ import org.slf4j.LoggerFactory; case 2: // LOGGERS if (field.type == org.apache.thrift.protocol.TType.SET) { { - org.apache.thrift.protocol.TSet _set97 = iprot.readSetBegin(); - this.loggers = new HashSet(2*_set97.size); - for (int _i98 = 0; _i98 < _set97.size; ++_i98) + org.apache.thrift.protocol.TSet _set106 = iprot.readSetBegin(); + this.loggers = new HashSet(2*_set106.size); + for (int _i107 = 0; _i107 < _set106.size; ++_i107) { - String _elem99; - _elem99 = iprot.readString(); - this.loggers.add(_elem99); + String _elem108; + _elem108 = iprot.readString(); + this.loggers.add(_elem108); } iprot.readSetEnd(); } @@ -18734,9 +18734,9 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(LOGGERS_FIELD_DESC); { oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, this.loggers.size())); - for (String _iter100 : this.loggers) + for (String _iter109 : this.loggers) { - oprot.writeString(_iter100); + oprot.writeString(_iter109); } oprot.writeSetEnd(); } @@ -20376,14 +20376,14 @@ import org.slf4j.LoggerFactory; case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list101 = iprot.readListBegin(); - this.success = new ArrayList(_list101.size); - for (int _i102 = 0; _i102 < _list101.size; ++_i102) + org.apache.thrift.protocol.TList _list110 = iprot.readListBegin(); + this.success = new ArrayList(_list110.size); + for (int _i111 = 0; _i111 < _list110.size; ++_i111) { - TabletStats _elem103; - _elem103 = new TabletStats(); - _elem103.read(iprot); - this.success.add(_elem103); + TabletStats _elem112; + _elem112 = new TabletStats(); + _elem112.read(iprot); + this.success.add(_elem112); } iprot.readListEnd(); } @@ -20417,9 +20417,9 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (TabletStats _iter104 : this.success) + for (TabletStats _iter113 : this.success) { - _iter104.write(oprot); + _iter113.write(oprot); } oprot.writeListEnd(); } @@ -23212,14 +23212,14 @@ import org.slf4j.LoggerFactory; case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list105 = iprot.readListBegin(); - this.success = new ArrayList(_list105.size); - for (int _i106 = 0; _i106 < _list105.size; ++_i106) + org.apache.thrift.protocol.TList _list114 = iprot.readListBegin(); + this.success = new ArrayList(_list114.size); + for (int _i115 = 0; _i115 < _list114.size; ++_i115) { - ActiveScan _elem107; - _elem107 = new ActiveScan(); - _elem107.read(iprot); - this.success.add(_elem107); + ActiveScan _elem116; + _elem116 = new ActiveScan(); + _elem116.read(iprot); + this.success.add(_elem116); } iprot.readListEnd(); } @@ -23253,9 +23253,9 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (ActiveScan _iter108 : this.success) + for (ActiveScan _iter117 : this.success) { - _iter108.write(oprot); + _iter117.write(oprot); } oprot.writeListEnd(); } Modified: accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/TabletMutations.java URL: http://svn.apache.org/viewvc/accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/TabletMutations.java?rev=1342122&r1=1342121&r2=1342122&view=diff ============================================================================== --- accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/TabletMutations.java (original) +++ accumulo/trunk/core/src/main/java/org/apache/accumulo/core/tabletserver/thrift/TabletMutations.java Thu May 24 03:05:14 2012 @@ -428,14 +428,14 @@ import org.slf4j.LoggerFactory; case 3: // MUTATIONS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list22 = iprot.readListBegin(); - this.mutations = new ArrayList(_list22.size); - for (int _i23 = 0; _i23 < _list22.size; ++_i23) + org.apache.thrift.protocol.TList _list31 = iprot.readListBegin(); + this.mutations = new ArrayList(_list31.size); + for (int _i32 = 0; _i32 < _list31.size; ++_i32) { - org.apache.accumulo.core.data.thrift.TMutation _elem24; - _elem24 = new org.apache.accumulo.core.data.thrift.TMutation(); - _elem24.read(iprot); - this.mutations.add(_elem24); + org.apache.accumulo.core.data.thrift.TMutation _elem33; + _elem33 = new org.apache.accumulo.core.data.thrift.TMutation(); + _elem33.read(iprot); + this.mutations.add(_elem33); } iprot.readListEnd(); } @@ -468,9 +468,9 @@ import org.slf4j.LoggerFactory; oprot.writeFieldBegin(MUTATIONS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.mutations.size())); - for (org.apache.accumulo.core.data.thrift.TMutation _iter25 : this.mutations) + for (org.apache.accumulo.core.data.thrift.TMutation _iter34 : this.mutations) { - _iter25.write(oprot); + _iter34.write(oprot); } oprot.writeListEnd(); } Modified: accumulo/trunk/core/src/main/thrift/tabletserver.thrift URL: http://svn.apache.org/viewvc/accumulo/trunk/core/src/main/thrift/tabletserver.thrift?rev=1342122&r1=1342121&r2=1342122&view=diff ============================================================================== --- accumulo/trunk/core/src/main/thrift/tabletserver.thrift (original) +++ accumulo/trunk/core/src/main/thrift/tabletserver.thrift Thu May 24 03:05:14 2012 @@ -85,6 +85,17 @@ struct ActiveScan { 12:map> ssio /* Server Side Iterator Options */ } +struct TIteratorSetting { + 1:i32 priority; + 2:string name; + 3:string iteratorClass; + 4:map properties; +} + +struct IteratorConfig { + 1:list iterators; +} + service TabletClientService extends client.ClientService { // scan a range of keys data.InitialScan startScan(11:cloudtrace.TInfo tinfo,