diff --git a/CHANGES.txt b/CHANGES.txt index 55a1b055bea..23de621969e 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -429,6 +429,7 @@ Release 0.91.0 - Unreleased HBASE-2233 Support both Hadoop 0.20 and 0.22 HBASE-3857 Change the HFile Format (Mikhail & Liyin) HBASE-4114 Metrics for HFile HDFS block locality (Ming Ma) + HBASE-4176 Exposing HBase Filters to the Thrift API (Anirudh Todi) Release 0.90.5 - Unreleased diff --git a/src/main/java/org/apache/hadoop/hbase/filter/ColumnCountGetFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/ColumnCountGetFilter.java index 306ed2160aa..26f11aa029f 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/ColumnCountGetFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/ColumnCountGetFilter.java @@ -25,6 +25,9 @@ import org.apache.hadoop.hbase.KeyValue; import java.io.DataInput; import java.io.DataOutput; import java.io.IOException; +import java.util.ArrayList; + +import com.google.common.base.Preconditions; /** * Simple filter that returns first N columns on row only. @@ -45,6 +48,7 @@ public class ColumnCountGetFilter extends FilterBase { } public ColumnCountGetFilter(final int n) { + Preconditions.checkArgument(n >= 0, "limit be positive %s", n); this.limit = n; } @@ -68,6 +72,13 @@ public class ColumnCountGetFilter extends FilterBase { this.count = 0; } + public static Filter createFilterFromArguments(ArrayList filterArguments) { + Preconditions.checkArgument(filterArguments.size() == 1, + "Expected 1 but got: %s", filterArguments.size()); + int limit = ParseFilter.convertByteArrayToInt(filterArguments.get(0)); + return new ColumnCountGetFilter(limit); + } + @Override public void readFields(DataInput in) throws IOException { this.limit = in.readInt(); diff --git a/src/main/java/org/apache/hadoop/hbase/filter/ColumnPaginationFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/ColumnPaginationFilter.java index 52bbdf934c7..85b0af77673 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/ColumnPaginationFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/ColumnPaginationFilter.java @@ -22,8 +22,10 @@ package org.apache.hadoop.hbase.filter; import java.io.DataInput; import java.io.DataOutput; import java.io.IOException; +import java.util.ArrayList; import org.apache.hadoop.hbase.KeyValue; +import com.google.common.base.Preconditions; /** * A filter, based on the ColumnCountGetFilter, takes two arguments: limit and offset. @@ -46,6 +48,8 @@ public class ColumnPaginationFilter extends FilterBase public ColumnPaginationFilter(final int limit, final int offset) { + Preconditions.checkArgument(limit >= 0, "limit must be positive %s", limit); + Preconditions.checkArgument(offset >= 0, "offset must be positive %s", offset); this.limit = limit; this.offset = offset; } @@ -83,6 +87,14 @@ public class ColumnPaginationFilter extends FilterBase this.count = 0; } + public static Filter createFilterFromArguments(ArrayList filterArguments) { + Preconditions.checkArgument(filterArguments.size() == 2, + "Expected 2 but got: %s", filterArguments.size()); + int limit = ParseFilter.convertByteArrayToInt(filterArguments.get(0)); + int offset = ParseFilter.convertByteArrayToInt(filterArguments.get(1)); + return new ColumnPaginationFilter(limit, offset); + } + public void readFields(DataInput in) throws IOException { this.limit = in.readInt(); diff --git a/src/main/java/org/apache/hadoop/hbase/filter/ColumnPrefixFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/ColumnPrefixFilter.java index 0fcdcb69f4a..931c7ad8d16 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/ColumnPrefixFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/ColumnPrefixFilter.java @@ -26,6 +26,9 @@ import org.apache.hadoop.hbase.util.Bytes; import java.io.DataOutput; import java.io.IOException; import java.io.DataInput; +import java.util.ArrayList; + +import com.google.common.base.Preconditions; /** * This filter is used for selecting only those keys with columns that matches @@ -78,6 +81,13 @@ public class ColumnPrefixFilter extends FilterBase { } } + public static Filter createFilterFromArguments(ArrayList filterArguments) { + Preconditions.checkArgument(filterArguments.size() == 1, + "Expected 1 but got: %s", filterArguments.size()); + byte [] columnPrefix = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); + return new ColumnPrefixFilter(columnPrefix); + } + public void write(DataOutput out) throws IOException { Bytes.writeByteArray(out, this.prefix); } diff --git a/src/main/java/org/apache/hadoop/hbase/filter/ColumnRangeFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/ColumnRangeFilter.java index 828a813b04f..df8786c7b61 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/ColumnRangeFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/ColumnRangeFilter.java @@ -26,6 +26,9 @@ import org.apache.hadoop.hbase.util.Bytes; import java.io.DataOutput; import java.io.IOException; import java.io.DataInput; +import java.util.ArrayList; + +import com.google.common.base.Preconditions; /** * This filter is used for selecting only those keys with columns that are @@ -143,6 +146,22 @@ public class ColumnRangeFilter extends FilterBase { return ReturnCode.NEXT_ROW; } + public static Filter createFilterFromArguments(ArrayList filterArguments) { + Preconditions.checkArgument(filterArguments.size() == 4, + "Expected 4 but got: %s", filterArguments.size()); + byte [] minColumn = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); + boolean minColumnInclusive = ParseFilter.convertByteArrayToBoolean(filterArguments.get(1)); + byte [] maxColumn = ParseFilter.removeQuotesFromByteArray(filterArguments.get(2)); + boolean maxColumnInclusive = ParseFilter.convertByteArrayToBoolean(filterArguments.get(3)); + + if (minColumn.length == 0) + minColumn = null; + if (maxColumn.length == 0) + maxColumn = null; + return new ColumnRangeFilter(minColumn, minColumnInclusive, + maxColumn, maxColumnInclusive); + } + @Override public void write(DataOutput out) throws IOException { // need to write out a flag for null value separately. Otherwise, diff --git a/src/main/java/org/apache/hadoop/hbase/filter/CompareFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/CompareFilter.java index 6d734396fe2..c32091846e9 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/CompareFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/CompareFilter.java @@ -27,7 +27,9 @@ import java.io.DataInput; import java.io.DataOutput; import java.io.IOException; import java.util.Arrays; +import java.util.ArrayList; +import com.google.common.base.Preconditions; /** * This is a generic filter to be used to filter by comparison. It takes an * operator (equal, greater, not equal, etc) and a byte [] comparator. @@ -125,6 +127,27 @@ public abstract class CompareFilter extends FilterBase { } } + public static ArrayList extractArguments(ArrayList filterArguments) { + Preconditions.checkArgument(filterArguments.size() == 2, + "Expected 2 but got: %s", filterArguments.size()); + CompareOp compareOp = ParseFilter.createCompareOp(filterArguments.get(0)); + WritableByteArrayComparable comparator = ParseFilter.createComparator( + ParseFilter.removeQuotesFromByteArray(filterArguments.get(1))); + + if (comparator instanceof RegexStringComparator || + comparator instanceof SubstringComparator) { + if (compareOp != CompareOp.EQUAL && + compareOp != CompareOp.NOT_EQUAL) { + throw new IllegalArgumentException ("A regexstring comparator and substring comparator" + + " can only be used with EQUAL and NOT_EQUAL"); + } + } + ArrayList arguments = new ArrayList(); + arguments.add(compareOp); + arguments.add(comparator); + return arguments; + } + public void readFields(DataInput in) throws IOException { compareOp = CompareOp.valueOf(in.readUTF()); comparator = (WritableByteArrayComparable) diff --git a/src/main/java/org/apache/hadoop/hbase/filter/DependentColumnFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/DependentColumnFilter.java index 6f76fe068d5..1f04dff44e2 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/DependentColumnFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/DependentColumnFilter.java @@ -26,10 +26,13 @@ import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Set; +import java.util.ArrayList; import org.apache.hadoop.hbase.KeyValue; import org.apache.hadoop.hbase.util.Bytes; +import com.google.common.base.Preconditions; + /** * A filter for adding inter-column timestamp matching * Only cells with a correspondingly timestamped entry in @@ -120,6 +123,10 @@ public class DependentColumnFilter extends CompareFilter { return this.dropDependentColumn; } + public boolean getDropDependentColumn() { + return this.dropDependentColumn; + } + @Override public boolean filterAllRemaining() { return false; @@ -169,12 +176,41 @@ public class DependentColumnFilter extends CompareFilter { public boolean filterRowKey(byte[] buffer, int offset, int length) { return false; } - @Override public void reset() { stampSet.clear(); } + public static Filter createFilterFromArguments(ArrayList filterArguments) { + Preconditions.checkArgument(filterArguments.size() == 2 || + filterArguments.size() == 3 || + filterArguments.size() == 5, + "Expected 2, 3 or 5 but got: %s", filterArguments.size()); + if (filterArguments.size() == 2) { + byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); + byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1)); + return new DependentColumnFilter(family, qualifier); + + } else if (filterArguments.size() == 3) { + byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); + byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1)); + boolean dropDependentColumn = ParseFilter.convertByteArrayToBoolean(filterArguments.get(2)); + return new DependentColumnFilter(family, qualifier, dropDependentColumn); + + } else if (filterArguments.size() == 5) { + byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); + byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1)); + boolean dropDependentColumn = ParseFilter.convertByteArrayToBoolean(filterArguments.get(2)); + CompareOp compareOp = ParseFilter.createCompareOp(filterArguments.get(3)); + WritableByteArrayComparable comparator = ParseFilter.createComparator( + ParseFilter.removeQuotesFromByteArray(filterArguments.get(4))); + return new DependentColumnFilter(family, qualifier, dropDependentColumn, + compareOp, comparator); + } else { + throw new IllegalArgumentException("Expected 2, 3 or 5 but got: " + filterArguments.size()); + } + } + @Override public void readFields(DataInput in) throws IOException { super.readFields(in); diff --git a/src/main/java/org/apache/hadoop/hbase/filter/FamilyFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/FamilyFilter.java index 03e16c40883..63ec44a6a27 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/FamilyFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/FamilyFilter.java @@ -22,6 +22,8 @@ package org.apache.hadoop.hbase.filter; import org.apache.hadoop.hbase.KeyValue; +import java.util.ArrayList; + /** * This filter is used to filter based on the column family. It takes an * operator (equal, greater, not equal, etc) and a byte [] comparator for the @@ -64,4 +66,11 @@ public class FamilyFilter extends CompareFilter { } return ReturnCode.INCLUDE; } + + public static Filter createFilterFromArguments(ArrayList filterArguments) { + ArrayList arguments = CompareFilter.extractArguments(filterArguments); + CompareOp compareOp = (CompareOp)arguments.get(0); + WritableByteArrayComparable comparator = (WritableByteArrayComparable)arguments.get(1); + return new FamilyFilter(compareOp, comparator); +} } diff --git a/src/main/java/org/apache/hadoop/hbase/filter/FilterBase.java b/src/main/java/org/apache/hadoop/hbase/filter/FilterBase.java index fc775c4e10e..2803516a2a0 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/FilterBase.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/FilterBase.java @@ -22,6 +22,7 @@ package org.apache.hadoop.hbase.filter; import org.apache.hadoop.hbase.KeyValue; import java.util.List; +import java.util.ArrayList; /** * Abstract base class to help you implement new Filters. Common "ignore" or NOOP type @@ -119,4 +120,13 @@ public abstract class FilterBase implements Filter { return null; } + /** + * Given the filter's arguments it constructs the filter + *

+ * @param filterArguments the filter's arguments + * @return constructed filter object + */ + public static Filter createFilterFromArguments(ArrayList filterArguments) { + throw new IllegalArgumentException("This method has not been implemented"); +} } diff --git a/src/main/java/org/apache/hadoop/hbase/filter/FirstKeyOnlyFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/FirstKeyOnlyFilter.java index 36170bfa360..7a068b4d981 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/FirstKeyOnlyFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/FirstKeyOnlyFilter.java @@ -25,6 +25,9 @@ import java.io.DataOutput; import java.io.IOException; import java.io.DataInput; import java.util.List; +import java.util.ArrayList; + +import com.google.common.base.Preconditions; /** * A filter that will only return the first KV from each row. @@ -47,6 +50,12 @@ public class FirstKeyOnlyFilter extends FilterBase { return ReturnCode.INCLUDE; } + public static Filter createFilterFromArguments(ArrayList filterArguments) { + Preconditions.checkArgument(filterArguments.size() == 0, + "Expected 0 but got: %s", filterArguments.size()); + return new FirstKeyOnlyFilter(); + } + public void write(DataOutput out) throws IOException { } diff --git a/src/main/java/org/apache/hadoop/hbase/filter/InclusiveStopFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/InclusiveStopFilter.java index 6148f3538cd..091800c8ebc 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/InclusiveStopFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/InclusiveStopFilter.java @@ -27,6 +27,9 @@ import java.io.DataInput; import java.io.DataOutput; import java.io.IOException; import java.util.List; +import java.util.ArrayList; + +import com.google.common.base.Preconditions; /** * A Filter that stops after the given row. There is no "RowStopFilter" because @@ -72,6 +75,13 @@ public class InclusiveStopFilter extends FilterBase { return done; } + public static Filter createFilterFromArguments (ArrayList filterArguments) { + Preconditions.checkArgument(filterArguments.size() == 1, + "Expected 1 but got: %s", filterArguments.size()); + byte [] stopRowKey = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); + return new InclusiveStopFilter(stopRowKey); + } + public void write(DataOutput out) throws IOException { Bytes.writeByteArray(out, this.stopRowKey); } diff --git a/src/main/java/org/apache/hadoop/hbase/filter/KeyOnlyFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/KeyOnlyFilter.java index d417efd02db..9f99e2cafe1 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/KeyOnlyFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/KeyOnlyFilter.java @@ -25,6 +25,10 @@ import java.io.IOException; import org.apache.hadoop.hbase.KeyValue; import org.apache.hadoop.hbase.util.Bytes; +import java.util.ArrayList; + +import com.google.common.base.Preconditions; + /** * A filter that will only return the key component of each KV (the value will * be rewritten as empty). @@ -44,6 +48,12 @@ public class KeyOnlyFilter extends FilterBase { return ReturnCode.INCLUDE; } + public static Filter createFilterFromArguments(ArrayList filterArguments) { + Preconditions.checkArgument(filterArguments.size() == 0, + "Expected: 0 but got: %s", filterArguments.size()); + return new KeyOnlyFilter(); + } + public void write(DataOutput out) throws IOException { out.writeBoolean(this.lenAsVal); } diff --git a/src/main/java/org/apache/hadoop/hbase/filter/MultipleColumnPrefixFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/MultipleColumnPrefixFilter.java index b9ff17ae8e7..233b295c97a 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/MultipleColumnPrefixFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/MultipleColumnPrefixFilter.java @@ -26,6 +26,7 @@ import java.io.DataInput; import java.util.Arrays; import java.util.Comparator; import java.util.TreeSet; +import java.util.ArrayList; /** * This filter is used for selecting only those keys with columns that matches @@ -92,6 +93,15 @@ public class MultipleColumnPrefixFilter extends FilterBase { } } + public static Filter createFilterFromArguments(ArrayList filterArguments) { + byte [][] prefixes = new byte [filterArguments.size()][]; + for (int i = 0 ; i < filterArguments.size(); i++) { + byte [] columnPrefix = ParseFilter.removeQuotesFromByteArray(filterArguments.get(i)); + prefixes[i] = columnPrefix; + } + return new MultipleColumnPrefixFilter(prefixes); + } + public void write(DataOutput out) throws IOException { out.writeInt(sortedPrefixes.size()); for (byte [] element : sortedPrefixes) { diff --git a/src/main/java/org/apache/hadoop/hbase/filter/PageFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/PageFilter.java index b5e4dd34677..9d66c757ceb 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/PageFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/PageFilter.java @@ -25,7 +25,9 @@ import java.io.DataInput; import java.io.DataOutput; import java.io.IOException; import java.util.List; +import java.util.ArrayList; +import com.google.common.base.Preconditions; /** * Implementation of Filter interface that limits results to a specific page * size. It terminates scanning once the number of filter-passed rows is > @@ -55,6 +57,7 @@ public class PageFilter extends FilterBase { * @param pageSize Maximum result size. */ public PageFilter(final long pageSize) { + Preconditions.checkArgument(pageSize >= 0, "must be positive %s", pageSize); this.pageSize = pageSize; } @@ -71,6 +74,13 @@ public class PageFilter extends FilterBase { return this.rowsAccepted > this.pageSize; } + public static Filter createFilterFromArguments(ArrayList filterArguments) { + Preconditions.checkArgument(filterArguments.size() == 1, + "Expected 1 but got: %s", filterArguments.size()); + long pageSize = ParseFilter.convertByteArrayToLong(filterArguments.get(0)); + return new PageFilter(pageSize); + } + public void readFields(final DataInput in) throws IOException { this.pageSize = in.readLong(); } diff --git a/src/main/java/org/apache/hadoop/hbase/filter/ParseConstants.java b/src/main/java/org/apache/hadoop/hbase/filter/ParseConstants.java index e69de29bb2d..373d7a68fbd 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/ParseConstants.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/ParseConstants.java @@ -0,0 +1,263 @@ +/** + * Copyright 2011 The Apache Software Foundation + * + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hbase.filter; + +import org.apache.hadoop.hbase.ipc.HRegionInterface; +import org.apache.hadoop.hbase.util.Bytes; +import java.nio.ByteBuffer; +import java.util.HashMap; +import org.apache.hadoop.hbase.filter.*; + +/** + * ParseConstants holds a bunch of constants related to parsing Filter Strings + * Used by {@link ParseFilter} + */ +public final class ParseConstants { + + /** + * ASCII code for LPAREN + */ + public static final int LPAREN = '('; + + /** + * ASCII code for RPAREN + */ + public static final int RPAREN = ')'; + + /** + * ASCII code for whitespace + */ + public static final int WHITESPACE = ' '; + + /** + * ASCII code for tab + */ + public static final int TAB = '\t'; + + /** + * ASCII code for 'A' + */ + public static final int A = 'A'; + + /** + * ASCII code for 'N' + */ + public static final int N = 'N'; + + /** + * ASCII code for 'D' + */ + public static final int D = 'D'; + + /** + * ASCII code for 'O' + */ + public static final int O = 'O'; + + /** + * ASCII code for 'R' + */ + public static final int R = 'R'; + + /** + * ASCII code for 'S' + */ + public static final int S = 'S'; + + /** + * ASCII code for 'K' + */ + public static final int K = 'K'; + + /** + * ASCII code for 'I' + */ + public static final int I = 'I'; + + /** + * ASCII code for 'P' + */ + public static final int P = 'P'; + + /** + * SKIP Array + */ + public static final byte [] SKIP_ARRAY = new byte [ ] {'S', 'K', 'I', 'P'}; + public static final ByteBuffer SKIP_BUFFER = ByteBuffer.wrap(SKIP_ARRAY); + + /** + * ASCII code for 'W' + */ + public static final int W = 'W'; + + /** + * ASCII code for 'H' + */ + public static final int H = 'H'; + + /** + * ASCII code for 'L' + */ + public static final int L = 'L'; + + /** + * ASCII code for 'E' + */ + public static final int E = 'E'; + + /** + * WHILE Array + */ + public static final byte [] WHILE_ARRAY = new byte [] {'W', 'H', 'I', 'L', 'E'}; + public static final ByteBuffer WHILE_BUFFER = ByteBuffer.wrap(WHILE_ARRAY); + + /** + * OR Array + */ + public static final byte [] OR_ARRAY = new byte [] {'O','R'}; + public static final ByteBuffer OR_BUFFER = ByteBuffer.wrap(OR_ARRAY); + + /** + * AND Array + */ + public static final byte [] AND_ARRAY = new byte [] {'A','N', 'D'}; + public static final ByteBuffer AND_BUFFER = ByteBuffer.wrap(AND_ARRAY); + + /** + * ASCII code for Backslash + */ + public static final int BACKSLASH = '\\'; + + /** + * ASCII code for a single quote + */ + public static final int SINGLE_QUOTE = '\''; + + /** + * ASCII code for a comma + */ + public static final int COMMA = ','; + + /** + * LESS_THAN Array + */ + public static final byte [] LESS_THAN_ARRAY = new byte [] {'<'}; + public static final ByteBuffer LESS_THAN_BUFFER = ByteBuffer.wrap(LESS_THAN_ARRAY); + + /** + * LESS_THAN_OR_EQUAL_TO Array + */ + public static final byte [] LESS_THAN_OR_EQUAL_TO_ARRAY = new byte [] {'<', '='}; + public static final ByteBuffer LESS_THAN_OR_EQUAL_TO_BUFFER = + ByteBuffer.wrap(LESS_THAN_OR_EQUAL_TO_ARRAY); + + /** + * GREATER_THAN Array + */ + public static final byte [] GREATER_THAN_ARRAY = new byte [] {'>'}; + public static final ByteBuffer GREATER_THAN_BUFFER = ByteBuffer.wrap(GREATER_THAN_ARRAY); + + /** + * GREATER_THAN_OR_EQUAL_TO Array + */ + public static final byte [] GREATER_THAN_OR_EQUAL_TO_ARRAY = new byte [] {'>', '='}; + public static final ByteBuffer GREATER_THAN_OR_EQUAL_TO_BUFFER = + ByteBuffer.wrap(GREATER_THAN_OR_EQUAL_TO_ARRAY); + + /** + * EQUAL_TO Array + */ + public static final byte [] EQUAL_TO_ARRAY = new byte [] {'='}; + public static final ByteBuffer EQUAL_TO_BUFFER = ByteBuffer.wrap(EQUAL_TO_ARRAY); + + /** + * NOT_EQUAL_TO Array + */ + public static final byte [] NOT_EQUAL_TO_ARRAY = new byte [] {'!', '='}; + public static final ByteBuffer NOT_EQUAL_TO_BUFFER = ByteBuffer.wrap(NOT_EQUAL_TO_ARRAY); + + /** + * ASCII code for equal to (=) + */ + public static final int EQUAL_TO = '='; + + /** + * AND Byte Array + */ + public static final byte [] AND = new byte [] {'A','N','D'}; + + /** + * OR Byte Array + */ + public static final byte [] OR = new byte [] {'O', 'R'}; + + /** + * LPAREN Array + */ + public static final byte [] LPAREN_ARRAY = new byte [] {'('}; + public static final ByteBuffer LPAREN_BUFFER = ByteBuffer.wrap(LPAREN_ARRAY); + + /** + * ASCII code for colon (:) + */ + public static final int COLON = ':'; + + /** + * ASCII code for Zero + */ + public static final int ZERO = '0'; + + /** + * ASCII code foe Nine + */ + public static final int NINE = '9'; + + /** + * BinaryType byte array + */ + public static final byte [] binaryType = new byte [] {'b','i','n','a','r','y'}; + + /** + * BinaryPrefixType byte array + */ + public static final byte [] binaryPrefixType = new byte [] {'b','i','n','a','r','y', + 'p','r','e','f','i','x'}; + + /** + * RegexStringType byte array + */ + public static final byte [] regexStringType = new byte [] {'r','e','g','e', 'x', + 's','t','r','i','n','g'}; + + /** + * SubstringType byte array + */ + public static final byte [] substringType = new byte [] {'s','u','b','s','t','r','i','n','g'}; + + /** + * ASCII for Minus Sign + */ + public static final int MINUS_SIGN = '-'; + + /** + * Package containing filters + */ + public static final String FILTER_PACKAGE = "org.apache.hadoop.hbase.filter"; +} \ No newline at end of file diff --git a/src/main/java/org/apache/hadoop/hbase/filter/ParseFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/ParseFilter.java index e69de29bb2d..adc7ceb221f 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/ParseFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/ParseFilter.java @@ -0,0 +1,796 @@ +/** + * Copyright 2011 The Apache Software Foundation + * + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hbase.filter; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.charset.CharacterCodingException; +import java.util.TreeSet; +import java.util.ArrayList; +import java.util.Stack; +import java.util.HashMap; + +import org.apache.hadoop.hbase.util.Bytes; +import org.apache.hadoop.hbase.util.Writables; +import org.apache.hadoop.hbase.KeyValue; +import org.apache.hadoop.hbase.filter.ParseConstants; + +import org.apache.hadoop.hbase.filter.FilterList; +import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp; +import java.lang.ArrayIndexOutOfBoundsException; +import java.lang.ClassCastException; +import java.lang.reflect.*; +import java.util.EmptyStackException; + +/** + * This class allows a user to specify a filter via a string + * The string is parsed using the methods of this class and + * a filter object is constructed. This filter object is then wrapped + * in a scanner object which is then returned + *

+ * This class addresses the HBASE-4168 JIRA. More documentaton on this + * Filter Language can be found at: https://issues.apache.org/jira/browse/HBASE-4176 + */ +public class ParseFilter { + + private HashMap operatorPrecedenceHashMap; + + /** + * Constructor + *

+ * Creates the operatorPrecedenceHashMap + */ + public ParseFilter() { + operatorPrecedenceHashMap = new HashMap(); + operatorPrecedenceHashMap.put(ParseConstants.SKIP_BUFFER, 1); + operatorPrecedenceHashMap.put(ParseConstants.WHILE_BUFFER, 1); + operatorPrecedenceHashMap.put(ParseConstants.AND_BUFFER, 2); + operatorPrecedenceHashMap.put(ParseConstants.OR_BUFFER, 3); + } + + /** + * Parses the filterString and constructs a filter using it + *

+ * @param filterString filter string given by the user + * @return filter object we constructed + */ + public Filter parseFilterString (String filterString) + throws CharacterCodingException { + return parseFilterString(Bytes.toBytes(filterString)); + } + + /** + * Parses the filterString and constructs a filter using it + *

+ * @param filterStringAsByteArray filter string given by the user + * @return filter object we constructed + */ + public Filter parseFilterString (byte [] filterStringAsByteArray) + throws CharacterCodingException { + // stack for the operators and parenthesis + Stack operatorStack = new Stack(); + // stack for the filter objects + Stack filterStack = new Stack(); + + Filter filter = null; + for (int i=0; i + * A simpleFilterExpression is of the form: FilterName('arg', 'arg', 'arg') + * The user given filter string can have many simpleFilterExpressions combined + * using operators. + *

+ * This function extracts a simpleFilterExpression from the + * larger filterString given the start offset of the simpler expression + *

+ * @param filterStringAsByteArray filter string given by the user + * @param filterExpressionStartOffset start index of the simple filter expression + * @return byte array containing the simple filter expression + */ + public byte [] extractFilterSimpleExpression (byte [] filterStringAsByteArray, + int filterExpressionStartOffset) + throws CharacterCodingException { + int quoteCount = 0; + for (int i=filterExpressionStartOffset; i + * @param filterStringAsByteArray filter string given by the user + * @return filter object we constructed + */ + public Filter parseSimpleFilterExpression (byte [] filterStringAsByteArray) + throws CharacterCodingException { + + String filterName = Bytes.toString(getFilterName(filterStringAsByteArray)); + ArrayList filterArguments = getFilterArguments(filterStringAsByteArray); + try { + filterName = ParseConstants.FILTER_PACKAGE + "." + filterName; + Class c = Class.forName(filterName); + Class[] argTypes = new Class [] {ArrayList.class}; + Method m = c.getDeclaredMethod("createFilterFromArguments", argTypes); + return (Filter) m.invoke(null,filterArguments); + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } catch (NoSuchMethodException e) { + e.printStackTrace(); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } catch (InvocationTargetException e) { + e.printStackTrace(); + } + throw new IllegalArgumentException("Incorrect filter string " + + new String(filterStringAsByteArray)); + } + +/** + * Returns the filter name given a simple filter expression + *

+ * @param filterStringAsByteArray a simple filter expression + * @return name of filter in the simple filter expression + */ + public static byte [] getFilterName (byte [] filterStringAsByteArray) { + int filterNameStartIndex = 0; + int filterNameEndIndex = 0; + + for (int i=filterNameStartIndex; i + * @param filter_string filter string given by the user + * @return an ArrayList containing the arguments of the filter in the filter string + */ + public static ArrayList getFilterArguments (byte [] filterStringAsByteArray) { + int argumentListStartIndex = KeyValue.getDelimiter(filterStringAsByteArray, 0, + filterStringAsByteArray.length, + ParseConstants.LPAREN); + if (argumentListStartIndex == -1) { + throw new IllegalArgumentException("Incorrect argument list"); + } + + int argumentStartIndex = 0; + int argumentEndIndex = 0; + ArrayList filterArguments = new ArrayList(); + + for (int i = argumentListStartIndex + 1; i, != etc + argumentStartIndex = i; + for (int j = argumentStartIndex; j < filterStringAsByteArray.length; j++) { + if (filterStringAsByteArray[j] == ParseConstants.WHITESPACE || + filterStringAsByteArray[j] == ParseConstants.COMMA || + filterStringAsByteArray[j] == ParseConstants.RPAREN) { + argumentEndIndex = j - 1; + i = j; + byte [] filterArgument = new byte [argumentEndIndex - argumentStartIndex + 1]; + Bytes.putBytes(filterArgument, 0, filterStringAsByteArray, + argumentStartIndex, argumentEndIndex - argumentStartIndex + 1); + filterArguments.add(filterArgument); + break; + } else if (j == filterStringAsByteArray.length - 1) { + throw new IllegalArgumentException("Incorrect argument list"); + } + } + } + } + return filterArguments; + } + +/** + * This function is called while parsing the filterString and an operator is parsed + *

+ * @param operatorStack the stack containing the operators and parenthesis + * @param filterStack the stack containing the filters + * @param operator the operator found while parsing the filterString + * @return returns the filterStack after evaluating the stack + */ + public void reduce(Stack operatorStack, + Stack filterStack, + ByteBuffer operator) { + while (!operatorStack.empty() && + !(ParseConstants.LPAREN_BUFFER.equals(operatorStack.peek())) && + hasHigherPriority(operatorStack.peek(), operator)) { + filterStack.push(popArguments(operatorStack, filterStack)); + } + } + + /** + * Pops an argument from the operator stack and the number of arguments required by the operator + * from the filterStack and evaluates them + *

+ * @param operatorStack the stack containing the operators + * @param filterStack the stack containing the filters + * @return the evaluated filter + */ + public static Filter popArguments (Stack operatorStack, Stack filterStack) { + ByteBuffer argumentOnTopOfStack = operatorStack.peek(); + + if (argumentOnTopOfStack.equals(ParseConstants.OR_BUFFER)) { + // The top of the stack is an OR + try { + ArrayList listOfFilters = new ArrayList(); + while (!operatorStack.empty() && operatorStack.peek().equals(ParseConstants.OR_BUFFER)) { + Filter filter = filterStack.pop(); + listOfFilters.add(0, filter); + operatorStack.pop(); + } + Filter filter = filterStack.pop(); + listOfFilters.add(0, filter); + Filter orFilter = new FilterList(FilterList.Operator.MUST_PASS_ONE, listOfFilters); + return orFilter; + } catch (EmptyStackException e) { + throw new IllegalArgumentException("Incorrect input string - an OR needs two filters"); + } + + } else if (argumentOnTopOfStack.equals(ParseConstants.AND_BUFFER)) { + // The top of the stack is an AND + try { + ArrayList listOfFilters = new ArrayList(); + while (!operatorStack.empty() && operatorStack.peek().equals(ParseConstants.AND_BUFFER)) { + Filter filter = filterStack.pop(); + listOfFilters.add(0, filter); + operatorStack.pop(); + } + Filter filter = filterStack.pop(); + listOfFilters.add(0, filter); + Filter andFilter = new FilterList(FilterList.Operator.MUST_PASS_ALL, listOfFilters); + return andFilter; + } catch (EmptyStackException e) { + throw new IllegalArgumentException("Incorrect input string - an AND needs two filters"); + } + + } else if (argumentOnTopOfStack.equals(ParseConstants.SKIP_BUFFER)) { + // The top of the stack is a SKIP + try { + Filter wrappedFilter = filterStack.pop(); + Filter skipFilter = new SkipFilter(wrappedFilter); + operatorStack.pop(); + return skipFilter; + } catch (EmptyStackException e) { + throw new IllegalArgumentException("Incorrect input string - a SKIP wraps a filter"); + } + + } else if (argumentOnTopOfStack.equals(ParseConstants.WHILE_BUFFER)) { + // The top of the stack is a WHILE + try { + Filter wrappedFilter = filterStack.pop(); + Filter whileMatchFilter = new WhileMatchFilter(wrappedFilter); + operatorStack.pop(); + return whileMatchFilter; + } catch (EmptyStackException e) { + throw new IllegalArgumentException("Incorrect input string - a WHILE wraps a filter"); + } + + } else if (argumentOnTopOfStack.equals(ParseConstants.LPAREN_BUFFER)) { + // The top of the stack is a LPAREN + try { + Filter filter = filterStack.pop(); + operatorStack.pop(); + return filter; + } catch (EmptyStackException e) { + throw new IllegalArgumentException("Incorrect Filter String"); + } + + } else { + throw new IllegalArgumentException("Incorrect arguments on operatorStack"); + } + } + +/** + * Returns which operator has higher precedence + *

+ * If a has higher precedence than b, it returns true + * If they have the same precedence, it returns false + */ + public boolean hasHigherPriority(ByteBuffer a, ByteBuffer b) { + if ((operatorPrecedenceHashMap.get(a) - operatorPrecedenceHashMap.get(b)) < 0) { + return true; + } + return false; + } + +/** + * Removes the single quote escaping a single quote - thus it returns an unescaped argument + *

+ * @param filterStringAsByteArray filter string given by user + * @param argumentStartIndex start index of the argument + * @param argumentEndIndex end index of the argument + * @return returns an unescaped argument + */ + public static byte [] createUnescapdArgument (byte [] filterStringAsByteArray, + int argumentStartIndex, int argumentEndIndex) { + int unescapedArgumentLength = 2; + for (int i = argumentStartIndex + 1; i <= argumentEndIndex - 1; i++) { + unescapedArgumentLength ++; + if (filterStringAsByteArray[i] == ParseConstants.SINGLE_QUOTE && + i != (argumentEndIndex - 1) && + filterStringAsByteArray[i+1] == ParseConstants.SINGLE_QUOTE) { + i++; + continue; + } + } + + byte [] unescapedArgument = new byte [unescapedArgumentLength]; + int count = 1; + unescapedArgument[0] = '\''; + for (int i = argumentStartIndex + 1; i <= argumentEndIndex - 1; i++) { + if (filterStringAsByteArray [i] == ParseConstants.SINGLE_QUOTE && + i != (argumentEndIndex - 1) && + filterStringAsByteArray [i+1] == ParseConstants.SINGLE_QUOTE) { + unescapedArgument[count++] = filterStringAsByteArray [i+1]; + i++; + } + else { + unescapedArgument[count++] = filterStringAsByteArray [i]; + } + } + unescapedArgument[unescapedArgumentLength - 1] = '\''; + return unescapedArgument; + } + +/** + * Checks if the current index of filter string we are on is the beginning of the keyword 'OR' + *

+ * @param filterStringAsByteArray filter string given by the user + * @param indexOfOr index at which an 'O' was read + * @return true if the keyword 'OR' is at the current index + */ + public static boolean checkForOr (byte [] filterStringAsByteArray, int indexOfOr) + throws CharacterCodingException, ArrayIndexOutOfBoundsException { + + try { + if (filterStringAsByteArray[indexOfOr] == ParseConstants.O && + filterStringAsByteArray[indexOfOr+1] == ParseConstants.R && + (filterStringAsByteArray[indexOfOr-1] == ParseConstants.WHITESPACE || + filterStringAsByteArray[indexOfOr-1] == ParseConstants.RPAREN) && + (filterStringAsByteArray[indexOfOr+2] == ParseConstants.WHITESPACE || + filterStringAsByteArray[indexOfOr+2] == ParseConstants.LPAREN)) { + return true; + } else { + return false; + } + } catch (ArrayIndexOutOfBoundsException e) { + return false; + } + } + +/** + * Checks if the current index of filter string we are on is the beginning of the keyword 'AND' + *

+ * @param filterStringAsByteArray filter string given by the user + * @param indexOfAnd index at which an 'A' was read + * @return true if the keyword 'AND' is at the current index + */ + public static boolean checkForAnd (byte [] filterStringAsByteArray, int indexOfAnd) + throws CharacterCodingException { + + try { + if (filterStringAsByteArray[indexOfAnd] == ParseConstants.A && + filterStringAsByteArray[indexOfAnd+1] == ParseConstants.N && + filterStringAsByteArray[indexOfAnd+2] == ParseConstants.D && + (filterStringAsByteArray[indexOfAnd-1] == ParseConstants.WHITESPACE || + filterStringAsByteArray[indexOfAnd-1] == ParseConstants.RPAREN) && + (filterStringAsByteArray[indexOfAnd+3] == ParseConstants.WHITESPACE || + filterStringAsByteArray[indexOfAnd+3] == ParseConstants.LPAREN)) { + return true; + } else { + return false; + } + } catch (ArrayIndexOutOfBoundsException e) { + return false; + } + } + +/** + * Checks if the current index of filter string we are on is the beginning of the keyword 'SKIP' + *

+ * @param filterStringAsByteArray filter string given by the user + * @param indexOfSkip index at which an 'S' was read + * @return true if the keyword 'SKIP' is at the current index + */ + public static boolean checkForSkip (byte [] filterStringAsByteArray, int indexOfSkip) + throws CharacterCodingException { + + try { + if (filterStringAsByteArray[indexOfSkip] == ParseConstants.S && + filterStringAsByteArray[indexOfSkip+1] == ParseConstants.K && + filterStringAsByteArray[indexOfSkip+2] == ParseConstants.I && + filterStringAsByteArray[indexOfSkip+3] == ParseConstants.P && + (indexOfSkip == 0 || + filterStringAsByteArray[indexOfSkip-1] == ParseConstants.WHITESPACE || + filterStringAsByteArray[indexOfSkip-1] == ParseConstants.RPAREN || + filterStringAsByteArray[indexOfSkip-1] == ParseConstants.LPAREN) && + (filterStringAsByteArray[indexOfSkip+4] == ParseConstants.WHITESPACE || + filterStringAsByteArray[indexOfSkip+4] == ParseConstants.LPAREN)) { + return true; + } else { + return false; + } + } catch (ArrayIndexOutOfBoundsException e) { + return false; + } + } + +/** + * Checks if the current index of filter string we are on is the beginning of the keyword 'WHILE' + *

+ * @param filterStringAsByteArray filter string given by the user + * @param indexOfWhile index at which an 'W' was read + * @return true if the keyword 'WHILE' is at the current index + */ + public static boolean checkForWhile (byte [] filterStringAsByteArray, int indexOfWhile) + throws CharacterCodingException { + + try { + if (filterStringAsByteArray[indexOfWhile] == ParseConstants.W && + filterStringAsByteArray[indexOfWhile+1] == ParseConstants.H && + filterStringAsByteArray[indexOfWhile+2] == ParseConstants.I && + filterStringAsByteArray[indexOfWhile+3] == ParseConstants.L && + filterStringAsByteArray[indexOfWhile+4] == ParseConstants.E && + (indexOfWhile == 0 || filterStringAsByteArray[indexOfWhile-1] == ParseConstants.WHITESPACE + || filterStringAsByteArray[indexOfWhile-1] == ParseConstants.RPAREN || + filterStringAsByteArray[indexOfWhile-1] == ParseConstants.LPAREN) && + (filterStringAsByteArray[indexOfWhile+5] == ParseConstants.WHITESPACE || + filterStringAsByteArray[indexOfWhile+5] == ParseConstants.LPAREN)) { + return true; + } else { + return false; + } + } catch (ArrayIndexOutOfBoundsException e) { + return false; + } + } + +/** + * Returns a boolean indicating whether the quote was escaped or not + *

+ * @param array byte array in which the quote was found + * @param quoteIndex index of the single quote + * @return returns true if the quote was unescaped + */ + public static boolean isQuoteUnescaped (byte [] array, int quoteIndex) { + if (array == null) { + throw new IllegalArgumentException("isQuoteUnescaped called with a null array"); + } + + if (quoteIndex == array.length - 1 || array[quoteIndex+1] != ParseConstants.SINGLE_QUOTE) { + return true; + } + else { + return false; + } + } + +/** + * Takes a quoted byte array and converts it into an unquoted byte array + * For example: given a byte array representing 'abc', it returns a + * byte array representing abc + *

+ * @param quotedByteArray the quoted byte array + * @return + */ + public static byte [] removeQuotesFromByteArray (byte [] quotedByteArray) { + if (quotedByteArray == null || + quotedByteArray.length < 2 || + quotedByteArray[0] != ParseConstants.SINGLE_QUOTE || + quotedByteArray[quotedByteArray.length - 1] != ParseConstants.SINGLE_QUOTE) { + throw new IllegalArgumentException("removeQuotesFromByteArray needs a quoted byte array"); + } else { + byte [] targetString = new byte [quotedByteArray.length - 2]; + Bytes.putBytes(targetString, 0, quotedByteArray, 1, quotedByteArray.length - 2); + return targetString; + } + } + +/** + * Converts an int expressed in a byte array to an actual int + *

+ * This doesn't use Bytes.toInt because that assumes + * that there will be {@link #SIZEOF_INT} bytes available. + *

+ * @param numberAsByteArray the int value expressed as a byte array + * @return the int value + */ + public static int convertByteArrayToInt (byte [] numberAsByteArray) { + + long tempResult = ParseFilter.convertByteArrayToLong(numberAsByteArray); + + if (tempResult > Integer.MAX_VALUE) { + throw new IllegalArgumentException("Integer Argument too large"); + } else if (tempResult < Integer.MIN_VALUE) { + throw new IllegalArgumentException("Integer Argument too small"); + } + + int result = (int) tempResult; + return result; + } + +/** + * Converts a long expressed in a byte array to an actual long + *

+ * This doesn't use Bytes.toLong because that assumes + * that there will be {@link #SIZEOF_LONG} bytes available. + *

+ * @param numberAsByteArray the long value expressed as a byte array + * @return the long value + */ + public static long convertByteArrayToLong (byte [] numberAsByteArray) { + if (numberAsByteArray == null) { + throw new IllegalArgumentException("convertByteArrayToLong called with a null array"); + } + + int i = 0; + long result = 0; + boolean isNegative = false; + + if (numberAsByteArray[i] == ParseConstants.MINUS_SIGN) { + i++; + isNegative = true; + } + + while (i != numberAsByteArray.length) { + if (numberAsByteArray[i] < ParseConstants.ZERO || + numberAsByteArray[i] > ParseConstants.NINE) { + throw new IllegalArgumentException("Byte Array should only contain digits"); + } + result = result*10 + (numberAsByteArray[i] - ParseConstants.ZERO); + if (result < 0) { + throw new IllegalArgumentException("Long Argument too large"); + } + i++; + } + + if (isNegative) { + return -result; + } else { + return result; + } + } + +/** + * Converts a boolean expressed in a byte array to an actual boolean + *

+ * This doesn't used Bytes.toBoolean because Bytes.toBoolean(byte []) + * assumes that 1 stands for true and 0 for false. + * Here, the byte array representing "true" and "false" is parsed + *

+ * @param booleanAsByteArray the boolean value expressed as a byte array + * @return the boolean value + */ + public static boolean convertByteArrayToBoolean (byte [] booleanAsByteArray) { + if (booleanAsByteArray == null) { + throw new IllegalArgumentException("convertByteArrayToBoolean called with a null array"); + } + + if (booleanAsByteArray.length == 4 && + (booleanAsByteArray[0] == 't' || booleanAsByteArray[0] == 'T') && + (booleanAsByteArray[1] == 'r' || booleanAsByteArray[1] == 'R') && + (booleanAsByteArray[2] == 'u' || booleanAsByteArray[2] == 'U') && + (booleanAsByteArray[3] == 'e' || booleanAsByteArray[3] == 'E')) { + return true; + } + else if (booleanAsByteArray.length == 5 && + (booleanAsByteArray[0] == 'f' || booleanAsByteArray[0] == 'F') && + (booleanAsByteArray[1] == 'a' || booleanAsByteArray[1] == 'A') && + (booleanAsByteArray[2] == 'l' || booleanAsByteArray[2] == 'L') && + (booleanAsByteArray[3] == 's' || booleanAsByteArray[3] == 'S') && + (booleanAsByteArray[4] == 'e' || booleanAsByteArray[4] == 'E')) { + return false; + } + else { + throw new IllegalArgumentException("Incorrect Boolean Expression"); + } + } + +/** + * Takes a compareOperator symbol as a byte array and returns the corresponding CompareOperator + *

+ * @param compareOpAsByteArray the comparatorOperator symbol as a byte array + * @return the Compare Operator + */ + public static CompareFilter.CompareOp createCompareOp (byte [] compareOpAsByteArray) { + ByteBuffer compareOp = ByteBuffer.wrap(compareOpAsByteArray); + if (compareOp.equals(ParseConstants.LESS_THAN_BUFFER)) + return CompareOp.LESS; + else if (compareOp.equals(ParseConstants.LESS_THAN_OR_EQUAL_TO_BUFFER)) + return CompareOp.LESS_OR_EQUAL; + else if (compareOp.equals(ParseConstants.GREATER_THAN_BUFFER)) + return CompareOp.GREATER; + else if (compareOp.equals(ParseConstants.GREATER_THAN_OR_EQUAL_TO_BUFFER)) + return CompareOp.GREATER_OR_EQUAL; + else if (compareOp.equals(ParseConstants.NOT_EQUAL_TO_BUFFER)) + return CompareOp.NOT_EQUAL; + else if (compareOp.equals(ParseConstants.EQUAL_TO_BUFFER)) + return CompareOp.EQUAL; + else + throw new IllegalArgumentException("Invalid compare operator"); + } + +/** + * Parses a comparator of the form comparatorType:comparatorValue form and returns a comparator + *

+ * @param comparator the comparator in the form comparatorType:comparatorValue + * @return the parsed comparator + */ + public static WritableByteArrayComparable createComparator (byte [] comparator) { + if (comparator == null) + throw new IllegalArgumentException("Incorrect Comparator"); + byte [][] parsedComparator = ParseFilter.parseComparator(comparator); + byte [] comparatorType = parsedComparator[0]; + byte [] comparatorValue = parsedComparator[1]; + + + if (Bytes.equals(comparatorType, ParseConstants.binaryType)) + return new BinaryComparator(comparatorValue); + else if (Bytes.equals(comparatorType, ParseConstants.binaryPrefixType)) + return new BinaryPrefixComparator(comparatorValue); + else if (Bytes.equals(comparatorType, ParseConstants.regexStringType)) + return new RegexStringComparator(new String(comparatorValue)); + else if (Bytes.equals(comparatorType, ParseConstants.substringType)) + return new SubstringComparator(new String(comparatorValue)); + else + throw new IllegalArgumentException("Incorrect comparatorType"); + } + +/** + * Splits a column in comparatorType:comparatorValue form into separate byte arrays + *

+ * @param comparator the comparator + * @return the parsed arguments of the comparator as a 2D byte array + */ + public static byte [][] parseComparator (byte [] comparator) { + final int index = KeyValue.getDelimiter(comparator, 0, comparator.length, ParseConstants.COLON); + if (index == -1) { + throw new IllegalArgumentException("Incorrect comparator"); + } + + byte [][] result = new byte [2][0]; + result[0] = new byte [index]; + System.arraycopy(comparator, 0, result[0], 0, index); + + final int len = comparator.length - (index + 1); + result[1] = new byte[len]; + System.arraycopy(comparator, index + 1, result[1], 0, len); + + return result; + } +} diff --git a/src/main/java/org/apache/hadoop/hbase/filter/PrefixFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/PrefixFilter.java index 063d06825a3..9de199b1c0a 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/PrefixFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/PrefixFilter.java @@ -27,6 +27,9 @@ import java.io.DataOutput; import java.io.IOException; import java.io.DataInput; import java.util.List; +import java.util.ArrayList; + +import com.google.common.base.Preconditions; /** * Pass results that have same row prefix. @@ -67,6 +70,13 @@ public class PrefixFilter extends FilterBase { return passedPrefix; } + public static Filter createFilterFromArguments(ArrayList filterArguments) { + Preconditions.checkArgument(filterArguments.size() == 1, + "Expected 1 but got: %s", filterArguments.size()); + byte [] prefix = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); + return new PrefixFilter(prefix); + } + public void write(DataOutput out) throws IOException { Bytes.writeByteArray(out, this.prefix); } diff --git a/src/main/java/org/apache/hadoop/hbase/filter/QualifierFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/QualifierFilter.java index 43bf526e0ce..cd69277611c 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/QualifierFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/QualifierFilter.java @@ -23,6 +23,8 @@ package org.apache.hadoop.hbase.filter; import org.apache.hadoop.hbase.KeyValue; import org.apache.hadoop.hbase.client.Get; +import java.util.ArrayList; + /** * This filter is used to filter based on the column qualifier. It takes an * operator (equal, greater, not equal, etc) and a byte [] comparator for the @@ -65,4 +67,11 @@ public class QualifierFilter extends CompareFilter { } return ReturnCode.INCLUDE; } + + public static Filter createFilterFromArguments(ArrayList filterArguments) { + ArrayList arguments = CompareFilter.extractArguments(filterArguments); + CompareOp compareOp = (CompareOp)arguments.get(0); + WritableByteArrayComparable comparator = (WritableByteArrayComparable)arguments.get(1); + return new QualifierFilter(compareOp, comparator); +} } diff --git a/src/main/java/org/apache/hadoop/hbase/filter/RowFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/RowFilter.java index 9d9d0a4dbf5..39c6b6d2ec4 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/RowFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/RowFilter.java @@ -21,9 +21,9 @@ package org.apache.hadoop.hbase.filter; import org.apache.hadoop.hbase.KeyValue; -import org.apache.hadoop.hbase.client.Scan; import java.util.List; +import java.util.ArrayList; /** * This filter is used to filter based on the key. It takes an operator @@ -83,4 +83,11 @@ public class RowFilter extends CompareFilter { public boolean filterRow() { return this.filterOutRow; } + + public static Filter createFilterFromArguments(ArrayList filterArguments) { + ArrayList arguments = CompareFilter.extractArguments(filterArguments); + CompareOp compareOp = (CompareOp)arguments.get(0); + WritableByteArrayComparable comparator = (WritableByteArrayComparable)arguments.get(1); + return new RowFilter(compareOp, comparator); + } } \ No newline at end of file diff --git a/src/main/java/org/apache/hadoop/hbase/filter/SingleColumnValueExcludeFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/SingleColumnValueExcludeFilter.java index cda1ccfb546..7c7607f13da 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/SingleColumnValueExcludeFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/SingleColumnValueExcludeFilter.java @@ -23,6 +23,8 @@ package org.apache.hadoop.hbase.filter; import org.apache.hadoop.hbase.KeyValue; import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp; +import java.util.ArrayList; + /** * A {@link Filter} that checks a single column value, but does not emit the * tested column. This will enable a performance boost over @@ -85,4 +87,18 @@ public class SingleColumnValueExcludeFilter extends SingleColumnValueFilter { } return superRetCode; } + + public static Filter createFilterFromArguments(ArrayList filterArguments) { + SingleColumnValueFilter tempFilter = (SingleColumnValueFilter) + SingleColumnValueFilter.createFilterFromArguments(filterArguments); + SingleColumnValueExcludeFilter filter = new SingleColumnValueExcludeFilter ( + tempFilter.getFamily(), tempFilter.getQualifier(), + tempFilter.getOperator(), tempFilter.getComparator()); + + if (filterArguments.size() == 6) { + filter.setFilterIfMissing(tempFilter.getFilterIfMissing()); + filter.setLatestVersionOnly(tempFilter.getLatestVersionOnly()); +} + return filter; + } } diff --git a/src/main/java/org/apache/hadoop/hbase/filter/SingleColumnValueFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/SingleColumnValueFilter.java index 929a51995c2..dc223f27bce 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/SingleColumnValueFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/SingleColumnValueFilter.java @@ -33,6 +33,9 @@ import java.io.DataOutput; import java.io.IOException; import java.util.Arrays; import java.util.List; +import java.util.ArrayList; + +import com.google.common.base.Preconditions; /** * This filter is used to filter cells based on value. It takes a {@link CompareFilter.CompareOp} @@ -247,6 +250,36 @@ public class SingleColumnValueFilter extends FilterBase { this.latestVersionOnly = latestVersionOnly; } + public static Filter createFilterFromArguments(ArrayList filterArguments) { + Preconditions.checkArgument(filterArguments.size() == 4 || filterArguments.size() == 6, + "Expected 4 or 6 but got: %s", filterArguments.size()); + byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); + byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1)); + CompareOp compareOp = ParseFilter.createCompareOp(filterArguments.get(2)); + WritableByteArrayComparable comparator = ParseFilter.createComparator( + ParseFilter.removeQuotesFromByteArray(filterArguments.get(3))); + + if (comparator instanceof RegexStringComparator || + comparator instanceof SubstringComparator) { + if (compareOp != CompareOp.EQUAL && + compareOp != CompareOp.NOT_EQUAL) { + throw new IllegalArgumentException ("A regexstring comparator and substring comparator " + + "can only be used with EQUAL and NOT_EQUAL"); + } + } + + SingleColumnValueFilter filter = new SingleColumnValueFilter(family, qualifier, + compareOp, comparator); + + if (filterArguments.size() == 6) { + boolean filterIfMissing = ParseFilter.convertByteArrayToBoolean(filterArguments.get(4)); + boolean latestVersionOnly = ParseFilter.convertByteArrayToBoolean(filterArguments.get(5)); + filter.setFilterIfMissing(filterIfMissing); + filter.setLatestVersionOnly(latestVersionOnly); + } + return filter; + } + public void readFields(final DataInput in) throws IOException { this.columnFamily = Bytes.readByteArray(in); if(this.columnFamily.length == 0) { diff --git a/src/main/java/org/apache/hadoop/hbase/filter/TimestampsFilter.java b/src/main/java/org/apache/hadoop/hbase/filter/TimestampsFilter.java index 60ce11483ed..e4ee03101df 100644 --- a/src/main/java/org/apache/hadoop/hbase/filter/TimestampsFilter.java +++ b/src/main/java/org/apache/hadoop/hbase/filter/TimestampsFilter.java @@ -6,8 +6,10 @@ import java.io.IOException; import java.util.ArrayList; import java.util.List; import java.util.TreeSet; +import java.util.ArrayList; import org.apache.hadoop.hbase.KeyValue; +import com.google.common.base.Preconditions; /** * Filter that returns only cells whose timestamp (version) is @@ -41,6 +43,9 @@ public class TimestampsFilter extends FilterBase { * @param timestamps */ public TimestampsFilter(List timestamps) { + for (Long timestamp : timestamps) { + Preconditions.checkArgument(timestamp >= 0, "must be positive %s", timestamp); + } this.timestamps = new TreeSet(timestamps); init(); } @@ -80,6 +85,15 @@ public class TimestampsFilter extends FilterBase { return ReturnCode.SKIP; } + public static Filter createFilterFromArguments(ArrayList filterArguments) { + ArrayList timestamps = new ArrayList(); + for (int i = 0; i filterArguments) { + ArrayList arguments = CompareFilter.extractArguments(filterArguments); + CompareOp compareOp = (CompareOp)arguments.get(0); + WritableByteArrayComparable comparator = (WritableByteArrayComparable)arguments.get(1); + return new ValueFilter(compareOp, comparator); +} } diff --git a/src/main/java/org/apache/hadoop/hbase/thrift/ThriftServer.java b/src/main/java/org/apache/hadoop/hbase/thrift/ThriftServer.java index 92b6d0008cf..e72cfa23cf9 100644 --- a/src/main/java/org/apache/hadoop/hbase/thrift/ThriftServer.java +++ b/src/main/java/org/apache/hadoop/hbase/thrift/ThriftServer.java @@ -58,6 +58,7 @@ import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.filter.Filter; import org.apache.hadoop.hbase.filter.PrefixFilter; import org.apache.hadoop.hbase.filter.WhileMatchFilter; +import org.apache.hadoop.hbase.filter.ParseFilter; import org.apache.hadoop.hbase.thrift.generated.AlreadyExists; import org.apache.hadoop.hbase.thrift.generated.BatchMutation; import org.apache.hadoop.hbase.thrift.generated.ColumnDescriptor; @@ -748,6 +749,10 @@ public class ThriftServer { } } } + if (tScan.isSetFilterString()) { + ParseFilter parseFilter = new ParseFilter(); + scan.setFilter(parseFilter.parseFilterString(tScan.getFilterString())); + } return addScanner(table.getScanner(scan)); } catch (IOException e) { throw new IOError(e.getMessage()); diff --git a/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java b/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java index 6d4b1deff8a..8465602441c 100644 --- a/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java +++ b/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java @@ -20,6 +20,12 @@ import java.util.Arrays; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.apache.thrift.*; +import org.apache.thrift.async.*; +import org.apache.thrift.meta_data.*; +import org.apache.thrift.transport.*; +import org.apache.thrift.protocol.*; + public class Hbase { public interface Iface { @@ -29,7 +35,7 @@ public class Hbase { * * @param tableName name of the table */ - public void enableTable(ByteBuffer tableName) throws IOError, org.apache.thrift.TException; + public void enableTable(ByteBuffer tableName) throws IOError, TException; /** * Disables a table (takes it off-line) If it is being served, the master @@ -37,25 +43,25 @@ public class Hbase { * * @param tableName name of the table */ - public void disableTable(ByteBuffer tableName) throws IOError, org.apache.thrift.TException; + public void disableTable(ByteBuffer tableName) throws IOError, TException; /** * @return true if table is on-line * * @param tableName name of the table to check */ - public boolean isTableEnabled(ByteBuffer tableName) throws IOError, org.apache.thrift.TException; + public boolean isTableEnabled(ByteBuffer tableName) throws IOError, TException; - public void compact(ByteBuffer tableNameOrRegionName) throws IOError, org.apache.thrift.TException; + public void compact(ByteBuffer tableNameOrRegionName) throws IOError, TException; - public void majorCompact(ByteBuffer tableNameOrRegionName) throws IOError, org.apache.thrift.TException; + public void majorCompact(ByteBuffer tableNameOrRegionName) throws IOError, TException; /** * List all the userspace tables. * * @return returns a list of names */ - public List getTableNames() throws IOError, org.apache.thrift.TException; + public List getTableNames() throws IOError, TException; /** * List all the column families assoicated with a table. @@ -64,7 +70,7 @@ public class Hbase { * * @param tableName table name */ - public Map getColumnDescriptors(ByteBuffer tableName) throws IOError, org.apache.thrift.TException; + public Map getColumnDescriptors(ByteBuffer tableName) throws IOError, TException; /** * List the regions associated with a table. @@ -73,7 +79,7 @@ public class Hbase { * * @param tableName table name */ - public List getTableRegions(ByteBuffer tableName) throws IOError, org.apache.thrift.TException; + public List getTableRegions(ByteBuffer tableName) throws IOError, TException; /** * Create a table with the specified column families. The name @@ -89,7 +95,7 @@ public class Hbase { * * @param columnFamilies list of column family descriptors */ - public void createTable(ByteBuffer tableName, List columnFamilies) throws IOError, IllegalArgument, AlreadyExists, org.apache.thrift.TException; + public void createTable(ByteBuffer tableName, List columnFamilies) throws IOError, IllegalArgument, AlreadyExists, TException; /** * Deletes a table @@ -99,7 +105,7 @@ public class Hbase { * * @param tableName name of table to delete */ - public void deleteTable(ByteBuffer tableName) throws IOError, org.apache.thrift.TException; + public void deleteTable(ByteBuffer tableName) throws IOError, TException; /** * Get a single TCell for the specified table, row, and column at the @@ -113,7 +119,7 @@ public class Hbase { * * @param column column name */ - public List get(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws IOError, org.apache.thrift.TException; + public List get(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws IOError, TException; /** * Get the specified number of versions for the specified table, @@ -129,7 +135,7 @@ public class Hbase { * * @param numVersions number of versions to retrieve */ - public List getVer(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, int numVersions) throws IOError, org.apache.thrift.TException; + public List getVer(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, int numVersions) throws IOError, TException; /** * Get the specified number of versions for the specified table, @@ -148,7 +154,7 @@ public class Hbase { * * @param numVersions number of versions to retrieve */ - public List getVerTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, int numVersions) throws IOError, org.apache.thrift.TException; + public List getVerTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, int numVersions) throws IOError, TException; /** * Get all the data for the specified table and row at the latest @@ -160,7 +166,7 @@ public class Hbase { * * @param row row key */ - public List getRow(ByteBuffer tableName, ByteBuffer row) throws IOError, org.apache.thrift.TException; + public List getRow(ByteBuffer tableName, ByteBuffer row) throws IOError, TException; /** * Get the specified columns for the specified table and row at the latest @@ -174,7 +180,7 @@ public class Hbase { * * @param columns List of columns to return, null for all columns */ - public List getRowWithColumns(ByteBuffer tableName, ByteBuffer row, List columns) throws IOError, org.apache.thrift.TException; + public List getRowWithColumns(ByteBuffer tableName, ByteBuffer row, List columns) throws IOError, TException; /** * Get all the data for the specified table and row at the specified @@ -188,7 +194,7 @@ public class Hbase { * * @param timestamp timestamp */ - public List getRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws IOError, org.apache.thrift.TException; + public List getRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws IOError, TException; /** * Get the specified columns for the specified table and row at the specified @@ -204,7 +210,7 @@ public class Hbase { * * @param timestamp */ - public List getRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp) throws IOError, org.apache.thrift.TException; + public List getRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp) throws IOError, TException; /** * Get all the data for the specified table and rows at the latest @@ -216,7 +222,7 @@ public class Hbase { * * @param rows row keys */ - public List getRows(ByteBuffer tableName, List rows) throws IOError, org.apache.thrift.TException; + public List getRows(ByteBuffer tableName, List rows) throws IOError, TException; /** * Get the specified columns for the specified table and rows at the latest @@ -230,7 +236,7 @@ public class Hbase { * * @param columns List of columns to return, null for all columns */ - public List getRowsWithColumns(ByteBuffer tableName, List rows, List columns) throws IOError, org.apache.thrift.TException; + public List getRowsWithColumns(ByteBuffer tableName, List rows, List columns) throws IOError, TException; /** * Get all the data for the specified table and rows at the specified @@ -244,7 +250,7 @@ public class Hbase { * * @param timestamp timestamp */ - public List getRowsTs(ByteBuffer tableName, List rows, long timestamp) throws IOError, org.apache.thrift.TException; + public List getRowsTs(ByteBuffer tableName, List rows, long timestamp) throws IOError, TException; /** * Get the specified columns for the specified table and rows at the specified @@ -260,7 +266,7 @@ public class Hbase { * * @param timestamp */ - public List getRowsWithColumnsTs(ByteBuffer tableName, List rows, List columns, long timestamp) throws IOError, org.apache.thrift.TException; + public List getRowsWithColumnsTs(ByteBuffer tableName, List rows, List columns, long timestamp) throws IOError, TException; /** * Apply a series of mutations (updates/deletes) to a row in a @@ -274,7 +280,7 @@ public class Hbase { * * @param mutations list of mutation commands */ - public void mutateRow(ByteBuffer tableName, ByteBuffer row, List mutations) throws IOError, IllegalArgument, org.apache.thrift.TException; + public void mutateRow(ByteBuffer tableName, ByteBuffer row, List mutations) throws IOError, IllegalArgument, TException; /** * Apply a series of mutations (updates/deletes) to a row in a @@ -290,7 +296,7 @@ public class Hbase { * * @param timestamp timestamp */ - public void mutateRowTs(ByteBuffer tableName, ByteBuffer row, List mutations, long timestamp) throws IOError, IllegalArgument, org.apache.thrift.TException; + public void mutateRowTs(ByteBuffer tableName, ByteBuffer row, List mutations, long timestamp) throws IOError, IllegalArgument, TException; /** * Apply a series of batches (each a series of mutations on a single row) @@ -302,7 +308,7 @@ public class Hbase { * * @param rowBatches list of row batches */ - public void mutateRows(ByteBuffer tableName, List rowBatches) throws IOError, IllegalArgument, org.apache.thrift.TException; + public void mutateRows(ByteBuffer tableName, List rowBatches) throws IOError, IllegalArgument, TException; /** * Apply a series of batches (each a series of mutations on a single row) @@ -316,7 +322,7 @@ public class Hbase { * * @param timestamp timestamp */ - public void mutateRowsTs(ByteBuffer tableName, List rowBatches, long timestamp) throws IOError, IllegalArgument, org.apache.thrift.TException; + public void mutateRowsTs(ByteBuffer tableName, List rowBatches, long timestamp) throws IOError, IllegalArgument, TException; /** * Atomically increment the column value specified. Returns the next value post increment. @@ -329,7 +335,7 @@ public class Hbase { * * @param value amount to increment by */ - public long atomicIncrement(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long value) throws IOError, IllegalArgument, org.apache.thrift.TException; + public long atomicIncrement(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long value) throws IOError, IllegalArgument, TException; /** * Delete all cells that match the passed row and column. @@ -340,7 +346,7 @@ public class Hbase { * * @param column name of column whose value is to be deleted */ - public void deleteAll(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws IOError, org.apache.thrift.TException; + public void deleteAll(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws IOError, TException; /** * Delete all cells that match the passed row and column and whose @@ -354,7 +360,7 @@ public class Hbase { * * @param timestamp timestamp */ - public void deleteAllTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp) throws IOError, org.apache.thrift.TException; + public void deleteAllTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp) throws IOError, TException; /** * Completely delete the row's cells. @@ -363,7 +369,7 @@ public class Hbase { * * @param row key of the row to be completely deleted. */ - public void deleteAllRow(ByteBuffer tableName, ByteBuffer row) throws IOError, org.apache.thrift.TException; + public void deleteAllRow(ByteBuffer tableName, ByteBuffer row) throws IOError, TException; /** * Completely delete the row's cells marked with a timestamp @@ -375,7 +381,7 @@ public class Hbase { * * @param timestamp timestamp */ - public void deleteAllRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws IOError, org.apache.thrift.TException; + public void deleteAllRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws IOError, TException; /** * Get a scanner on the current table, using the Scan instance @@ -385,7 +391,7 @@ public class Hbase { * * @param scan Scan instance */ - public int scannerOpenWithScan(ByteBuffer tableName, TScan scan) throws IOError, org.apache.thrift.TException; + public int scannerOpenWithScan(ByteBuffer tableName, TScan scan) throws IOError, TException; /** * Get a scanner on the current table starting at the specified row and @@ -402,7 +408,7 @@ public class Hbase { * columns of the specified column family are returned. It's also possible * to pass a regex in the column qualifier. */ - public int scannerOpen(ByteBuffer tableName, ByteBuffer startRow, List columns) throws IOError, org.apache.thrift.TException; + public int scannerOpen(ByteBuffer tableName, ByteBuffer startRow, List columns) throws IOError, TException; /** * Get a scanner on the current table starting and stopping at the @@ -423,7 +429,7 @@ public class Hbase { * columns of the specified column family are returned. It's also possible * to pass a regex in the column qualifier. */ - public int scannerOpenWithStop(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns) throws IOError, org.apache.thrift.TException; + public int scannerOpenWithStop(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns) throws IOError, TException; /** * Open a scanner for a given prefix. That is all rows will have the specified @@ -437,7 +443,7 @@ public class Hbase { * * @param columns the columns you want returned */ - public int scannerOpenWithPrefix(ByteBuffer tableName, ByteBuffer startAndPrefix, List columns) throws IOError, org.apache.thrift.TException; + public int scannerOpenWithPrefix(ByteBuffer tableName, ByteBuffer startAndPrefix, List columns) throws IOError, TException; /** * Get a scanner on the current table starting at the specified row and @@ -457,7 +463,7 @@ public class Hbase { * * @param timestamp timestamp */ - public int scannerOpenTs(ByteBuffer tableName, ByteBuffer startRow, List columns, long timestamp) throws IOError, org.apache.thrift.TException; + public int scannerOpenTs(ByteBuffer tableName, ByteBuffer startRow, List columns, long timestamp) throws IOError, TException; /** * Get a scanner on the current table starting and stopping at the @@ -481,7 +487,7 @@ public class Hbase { * * @param timestamp timestamp */ - public int scannerOpenWithStopTs(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns, long timestamp) throws IOError, org.apache.thrift.TException; + public int scannerOpenWithStopTs(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns, long timestamp) throws IOError, TException; /** * Returns the scanner's current row value and advances to the next @@ -497,7 +503,7 @@ public class Hbase { * * @param id id of a scanner returned by scannerOpen */ - public List scannerGet(int id) throws IOError, IllegalArgument, org.apache.thrift.TException; + public List scannerGet(int id) throws IOError, IllegalArgument, TException; /** * Returns, starting at the scanner's current row value nbRows worth of @@ -515,7 +521,7 @@ public class Hbase { * * @param nbRows number of results to return */ - public List scannerGetList(int id, int nbRows) throws IOError, IllegalArgument, org.apache.thrift.TException; + public List scannerGetList(int id, int nbRows) throws IOError, IllegalArgument, TException; /** * Closes the server-state associated with an open scanner. @@ -524,138 +530,138 @@ public class Hbase { * * @param id id of a scanner returned by scannerOpen */ - public void scannerClose(int id) throws IOError, IllegalArgument, org.apache.thrift.TException; + public void scannerClose(int id) throws IOError, IllegalArgument, TException; } public interface AsyncIface { - public void enableTable(ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void enableTable(ByteBuffer tableName, AsyncMethodCallback resultHandler) throws TException; - public void disableTable(ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void disableTable(ByteBuffer tableName, AsyncMethodCallback resultHandler) throws TException; - public void isTableEnabled(ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void isTableEnabled(ByteBuffer tableName, AsyncMethodCallback resultHandler) throws TException; - public void compact(ByteBuffer tableNameOrRegionName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void compact(ByteBuffer tableNameOrRegionName, AsyncMethodCallback resultHandler) throws TException; - public void majorCompact(ByteBuffer tableNameOrRegionName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void majorCompact(ByteBuffer tableNameOrRegionName, AsyncMethodCallback resultHandler) throws TException; - public void getTableNames(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getTableNames(AsyncMethodCallback resultHandler) throws TException; - public void getColumnDescriptors(ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getColumnDescriptors(ByteBuffer tableName, AsyncMethodCallback resultHandler) throws TException; - public void getTableRegions(ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getTableRegions(ByteBuffer tableName, AsyncMethodCallback resultHandler) throws TException; - public void createTable(ByteBuffer tableName, List columnFamilies, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void createTable(ByteBuffer tableName, List columnFamilies, AsyncMethodCallback resultHandler) throws TException; - public void deleteTable(ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void deleteTable(ByteBuffer tableName, AsyncMethodCallback resultHandler) throws TException; - public void get(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void get(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, AsyncMethodCallback resultHandler) throws TException; - public void getVer(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, int numVersions, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getVer(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, int numVersions, AsyncMethodCallback resultHandler) throws TException; - public void getVerTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, int numVersions, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getVerTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, int numVersions, AsyncMethodCallback resultHandler) throws TException; - public void getRow(ByteBuffer tableName, ByteBuffer row, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getRow(ByteBuffer tableName, ByteBuffer row, AsyncMethodCallback resultHandler) throws TException; - public void getRowWithColumns(ByteBuffer tableName, ByteBuffer row, List columns, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getRowWithColumns(ByteBuffer tableName, ByteBuffer row, List columns, AsyncMethodCallback resultHandler) throws TException; - public void getRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp, AsyncMethodCallback resultHandler) throws TException; - public void getRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp, AsyncMethodCallback resultHandler) throws TException; - public void getRows(ByteBuffer tableName, List rows, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getRows(ByteBuffer tableName, List rows, AsyncMethodCallback resultHandler) throws TException; - public void getRowsWithColumns(ByteBuffer tableName, List rows, List columns, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getRowsWithColumns(ByteBuffer tableName, List rows, List columns, AsyncMethodCallback resultHandler) throws TException; - public void getRowsTs(ByteBuffer tableName, List rows, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getRowsTs(ByteBuffer tableName, List rows, long timestamp, AsyncMethodCallback resultHandler) throws TException; - public void getRowsWithColumnsTs(ByteBuffer tableName, List rows, List columns, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getRowsWithColumnsTs(ByteBuffer tableName, List rows, List columns, long timestamp, AsyncMethodCallback resultHandler) throws TException; - public void mutateRow(ByteBuffer tableName, ByteBuffer row, List mutations, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void mutateRow(ByteBuffer tableName, ByteBuffer row, List mutations, AsyncMethodCallback resultHandler) throws TException; - public void mutateRowTs(ByteBuffer tableName, ByteBuffer row, List mutations, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void mutateRowTs(ByteBuffer tableName, ByteBuffer row, List mutations, long timestamp, AsyncMethodCallback resultHandler) throws TException; - public void mutateRows(ByteBuffer tableName, List rowBatches, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void mutateRows(ByteBuffer tableName, List rowBatches, AsyncMethodCallback resultHandler) throws TException; - public void mutateRowsTs(ByteBuffer tableName, List rowBatches, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void mutateRowsTs(ByteBuffer tableName, List rowBatches, long timestamp, AsyncMethodCallback resultHandler) throws TException; - public void atomicIncrement(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long value, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void atomicIncrement(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long value, AsyncMethodCallback resultHandler) throws TException; - public void deleteAll(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void deleteAll(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, AsyncMethodCallback resultHandler) throws TException; - public void deleteAllTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void deleteAllTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, AsyncMethodCallback resultHandler) throws TException; - public void deleteAllRow(ByteBuffer tableName, ByteBuffer row, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void deleteAllRow(ByteBuffer tableName, ByteBuffer row, AsyncMethodCallback resultHandler) throws TException; - public void deleteAllRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void deleteAllRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp, AsyncMethodCallback resultHandler) throws TException; - public void scannerOpenWithScan(ByteBuffer tableName, TScan scan, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void scannerOpenWithScan(ByteBuffer tableName, TScan scan, AsyncMethodCallback resultHandler) throws TException; - public void scannerOpen(ByteBuffer tableName, ByteBuffer startRow, List columns, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void scannerOpen(ByteBuffer tableName, ByteBuffer startRow, List columns, AsyncMethodCallback resultHandler) throws TException; - public void scannerOpenWithStop(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void scannerOpenWithStop(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns, AsyncMethodCallback resultHandler) throws TException; - public void scannerOpenWithPrefix(ByteBuffer tableName, ByteBuffer startAndPrefix, List columns, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void scannerOpenWithPrefix(ByteBuffer tableName, ByteBuffer startAndPrefix, List columns, AsyncMethodCallback resultHandler) throws TException; - public void scannerOpenTs(ByteBuffer tableName, ByteBuffer startRow, List columns, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void scannerOpenTs(ByteBuffer tableName, ByteBuffer startRow, List columns, long timestamp, AsyncMethodCallback resultHandler) throws TException; - public void scannerOpenWithStopTs(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void scannerOpenWithStopTs(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns, long timestamp, AsyncMethodCallback resultHandler) throws TException; - public void scannerGet(int id, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void scannerGet(int id, AsyncMethodCallback resultHandler) throws TException; - public void scannerGetList(int id, int nbRows, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void scannerGetList(int id, int nbRows, AsyncMethodCallback resultHandler) throws TException; - public void scannerClose(int id, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void scannerClose(int id, AsyncMethodCallback resultHandler) throws TException; } - public static class Client implements org.apache.thrift.TServiceClient, Iface { - public static class Factory implements org.apache.thrift.TServiceClientFactory { + public static class Client implements TServiceClient, Iface { + public static class Factory implements TServiceClientFactory { public Factory() {} - public Client getClient(org.apache.thrift.protocol.TProtocol prot) { + public Client getClient(TProtocol prot) { return new Client(prot); } - public Client getClient(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) { + public Client getClient(TProtocol iprot, TProtocol oprot) { return new Client(iprot, oprot); } } - public Client(org.apache.thrift.protocol.TProtocol prot) + public Client(TProtocol prot) { this(prot, prot); } - public Client(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) + public Client(TProtocol iprot, TProtocol oprot) { iprot_ = iprot; oprot_ = oprot; } - protected org.apache.thrift.protocol.TProtocol iprot_; - protected org.apache.thrift.protocol.TProtocol oprot_; + protected TProtocol iprot_; + protected TProtocol oprot_; protected int seqid_; - public org.apache.thrift.protocol.TProtocol getInputProtocol() + public TProtocol getInputProtocol() { return this.iprot_; } - public org.apache.thrift.protocol.TProtocol getOutputProtocol() + public TProtocol getOutputProtocol() { return this.oprot_; } - public void enableTable(ByteBuffer tableName) throws IOError, org.apache.thrift.TException + public void enableTable(ByteBuffer tableName) throws IOError, TException { send_enableTable(tableName); recv_enableTable(); } - public void send_enableTable(ByteBuffer tableName) throws org.apache.thrift.TException + public void send_enableTable(ByteBuffer tableName) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("enableTable", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("enableTable", TMessageType.CALL, ++seqid_)); enableTable_args args = new enableTable_args(); args.setTableName(tableName); args.write(oprot_); @@ -663,16 +669,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public void recv_enableTable() throws IOError, org.apache.thrift.TException + public void recv_enableTable() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "enableTable failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "enableTable failed: out of sequence response"); } enableTable_result result = new enableTable_result(); result.read(iprot_); @@ -683,15 +689,15 @@ public class Hbase { return; } - public void disableTable(ByteBuffer tableName) throws IOError, org.apache.thrift.TException + public void disableTable(ByteBuffer tableName) throws IOError, TException { send_disableTable(tableName); recv_disableTable(); } - public void send_disableTable(ByteBuffer tableName) throws org.apache.thrift.TException + public void send_disableTable(ByteBuffer tableName) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("disableTable", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("disableTable", TMessageType.CALL, ++seqid_)); disableTable_args args = new disableTable_args(); args.setTableName(tableName); args.write(oprot_); @@ -699,16 +705,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public void recv_disableTable() throws IOError, org.apache.thrift.TException + public void recv_disableTable() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "disableTable failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "disableTable failed: out of sequence response"); } disableTable_result result = new disableTable_result(); result.read(iprot_); @@ -719,15 +725,15 @@ public class Hbase { return; } - public boolean isTableEnabled(ByteBuffer tableName) throws IOError, org.apache.thrift.TException + public boolean isTableEnabled(ByteBuffer tableName) throws IOError, TException { send_isTableEnabled(tableName); return recv_isTableEnabled(); } - public void send_isTableEnabled(ByteBuffer tableName) throws org.apache.thrift.TException + public void send_isTableEnabled(ByteBuffer tableName) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("isTableEnabled", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.CALL, ++seqid_)); isTableEnabled_args args = new isTableEnabled_args(); args.setTableName(tableName); args.write(oprot_); @@ -735,16 +741,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public boolean recv_isTableEnabled() throws IOError, org.apache.thrift.TException + public boolean recv_isTableEnabled() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "isTableEnabled failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "isTableEnabled failed: out of sequence response"); } isTableEnabled_result result = new isTableEnabled_result(); result.read(iprot_); @@ -755,18 +761,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "isTableEnabled failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "isTableEnabled failed: unknown result"); } - public void compact(ByteBuffer tableNameOrRegionName) throws IOError, org.apache.thrift.TException + public void compact(ByteBuffer tableNameOrRegionName) throws IOError, TException { send_compact(tableNameOrRegionName); recv_compact(); } - public void send_compact(ByteBuffer tableNameOrRegionName) throws org.apache.thrift.TException + public void send_compact(ByteBuffer tableNameOrRegionName) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("compact", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("compact", TMessageType.CALL, ++seqid_)); compact_args args = new compact_args(); args.setTableNameOrRegionName(tableNameOrRegionName); args.write(oprot_); @@ -774,16 +780,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public void recv_compact() throws IOError, org.apache.thrift.TException + public void recv_compact() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "compact failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "compact failed: out of sequence response"); } compact_result result = new compact_result(); result.read(iprot_); @@ -794,15 +800,15 @@ public class Hbase { return; } - public void majorCompact(ByteBuffer tableNameOrRegionName) throws IOError, org.apache.thrift.TException + public void majorCompact(ByteBuffer tableNameOrRegionName) throws IOError, TException { send_majorCompact(tableNameOrRegionName); recv_majorCompact(); } - public void send_majorCompact(ByteBuffer tableNameOrRegionName) throws org.apache.thrift.TException + public void send_majorCompact(ByteBuffer tableNameOrRegionName) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("majorCompact", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("majorCompact", TMessageType.CALL, ++seqid_)); majorCompact_args args = new majorCompact_args(); args.setTableNameOrRegionName(tableNameOrRegionName); args.write(oprot_); @@ -810,16 +816,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public void recv_majorCompact() throws IOError, org.apache.thrift.TException + public void recv_majorCompact() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "majorCompact failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "majorCompact failed: out of sequence response"); } majorCompact_result result = new majorCompact_result(); result.read(iprot_); @@ -830,31 +836,31 @@ public class Hbase { return; } - public List getTableNames() throws IOError, org.apache.thrift.TException + public List getTableNames() throws IOError, TException { send_getTableNames(); return recv_getTableNames(); } - public void send_getTableNames() throws org.apache.thrift.TException + public void send_getTableNames() throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTableNames", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("getTableNames", TMessageType.CALL, ++seqid_)); getTableNames_args args = new getTableNames_args(); args.write(oprot_); oprot_.writeMessageEnd(); oprot_.getTransport().flush(); } - public List recv_getTableNames() throws IOError, org.apache.thrift.TException + public List recv_getTableNames() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "getTableNames failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getTableNames failed: out of sequence response"); } getTableNames_result result = new getTableNames_result(); result.read(iprot_); @@ -865,18 +871,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getTableNames failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTableNames failed: unknown result"); } - public Map getColumnDescriptors(ByteBuffer tableName) throws IOError, org.apache.thrift.TException + public Map getColumnDescriptors(ByteBuffer tableName) throws IOError, TException { send_getColumnDescriptors(tableName); return recv_getColumnDescriptors(); } - public void send_getColumnDescriptors(ByteBuffer tableName) throws org.apache.thrift.TException + public void send_getColumnDescriptors(ByteBuffer tableName) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getColumnDescriptors", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.CALL, ++seqid_)); getColumnDescriptors_args args = new getColumnDescriptors_args(); args.setTableName(tableName); args.write(oprot_); @@ -884,16 +890,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public Map recv_getColumnDescriptors() throws IOError, org.apache.thrift.TException + public Map recv_getColumnDescriptors() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "getColumnDescriptors failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getColumnDescriptors failed: out of sequence response"); } getColumnDescriptors_result result = new getColumnDescriptors_result(); result.read(iprot_); @@ -904,18 +910,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getColumnDescriptors failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "getColumnDescriptors failed: unknown result"); } - public List getTableRegions(ByteBuffer tableName) throws IOError, org.apache.thrift.TException + public List getTableRegions(ByteBuffer tableName) throws IOError, TException { send_getTableRegions(tableName); return recv_getTableRegions(); } - public void send_getTableRegions(ByteBuffer tableName) throws org.apache.thrift.TException + public void send_getTableRegions(ByteBuffer tableName) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTableRegions", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("getTableRegions", TMessageType.CALL, ++seqid_)); getTableRegions_args args = new getTableRegions_args(); args.setTableName(tableName); args.write(oprot_); @@ -923,16 +929,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public List recv_getTableRegions() throws IOError, org.apache.thrift.TException + public List recv_getTableRegions() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "getTableRegions failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getTableRegions failed: out of sequence response"); } getTableRegions_result result = new getTableRegions_result(); result.read(iprot_); @@ -943,18 +949,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getTableRegions failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTableRegions failed: unknown result"); } - public void createTable(ByteBuffer tableName, List columnFamilies) throws IOError, IllegalArgument, AlreadyExists, org.apache.thrift.TException + public void createTable(ByteBuffer tableName, List columnFamilies) throws IOError, IllegalArgument, AlreadyExists, TException { send_createTable(tableName, columnFamilies); recv_createTable(); } - public void send_createTable(ByteBuffer tableName, List columnFamilies) throws org.apache.thrift.TException + public void send_createTable(ByteBuffer tableName, List columnFamilies) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("createTable", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("createTable", TMessageType.CALL, ++seqid_)); createTable_args args = new createTable_args(); args.setTableName(tableName); args.setColumnFamilies(columnFamilies); @@ -963,16 +969,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public void recv_createTable() throws IOError, IllegalArgument, AlreadyExists, org.apache.thrift.TException + public void recv_createTable() throws IOError, IllegalArgument, AlreadyExists, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "createTable failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "createTable failed: out of sequence response"); } createTable_result result = new createTable_result(); result.read(iprot_); @@ -989,15 +995,15 @@ public class Hbase { return; } - public void deleteTable(ByteBuffer tableName) throws IOError, org.apache.thrift.TException + public void deleteTable(ByteBuffer tableName) throws IOError, TException { send_deleteTable(tableName); recv_deleteTable(); } - public void send_deleteTable(ByteBuffer tableName) throws org.apache.thrift.TException + public void send_deleteTable(ByteBuffer tableName) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteTable", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("deleteTable", TMessageType.CALL, ++seqid_)); deleteTable_args args = new deleteTable_args(); args.setTableName(tableName); args.write(oprot_); @@ -1005,16 +1011,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public void recv_deleteTable() throws IOError, org.apache.thrift.TException + public void recv_deleteTable() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "deleteTable failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "deleteTable failed: out of sequence response"); } deleteTable_result result = new deleteTable_result(); result.read(iprot_); @@ -1025,15 +1031,15 @@ public class Hbase { return; } - public List get(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws IOError, org.apache.thrift.TException + public List get(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws IOError, TException { send_get(tableName, row, column); return recv_get(); } - public void send_get(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws org.apache.thrift.TException + public void send_get(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("get", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("get", TMessageType.CALL, ++seqid_)); get_args args = new get_args(); args.setTableName(tableName); args.setRow(row); @@ -1043,16 +1049,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public List recv_get() throws IOError, org.apache.thrift.TException + public List recv_get() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "get failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "get failed: out of sequence response"); } get_result result = new get_result(); result.read(iprot_); @@ -1063,18 +1069,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "get failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "get failed: unknown result"); } - public List getVer(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, int numVersions) throws IOError, org.apache.thrift.TException + public List getVer(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, int numVersions) throws IOError, TException { send_getVer(tableName, row, column, numVersions); return recv_getVer(); } - public void send_getVer(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, int numVersions) throws org.apache.thrift.TException + public void send_getVer(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, int numVersions) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getVer", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("getVer", TMessageType.CALL, ++seqid_)); getVer_args args = new getVer_args(); args.setTableName(tableName); args.setRow(row); @@ -1085,16 +1091,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public List recv_getVer() throws IOError, org.apache.thrift.TException + public List recv_getVer() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "getVer failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getVer failed: out of sequence response"); } getVer_result result = new getVer_result(); result.read(iprot_); @@ -1105,18 +1111,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getVer failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "getVer failed: unknown result"); } - public List getVerTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, int numVersions) throws IOError, org.apache.thrift.TException + public List getVerTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, int numVersions) throws IOError, TException { send_getVerTs(tableName, row, column, timestamp, numVersions); return recv_getVerTs(); } - public void send_getVerTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, int numVersions) throws org.apache.thrift.TException + public void send_getVerTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, int numVersions) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getVerTs", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("getVerTs", TMessageType.CALL, ++seqid_)); getVerTs_args args = new getVerTs_args(); args.setTableName(tableName); args.setRow(row); @@ -1128,16 +1134,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public List recv_getVerTs() throws IOError, org.apache.thrift.TException + public List recv_getVerTs() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "getVerTs failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getVerTs failed: out of sequence response"); } getVerTs_result result = new getVerTs_result(); result.read(iprot_); @@ -1148,18 +1154,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getVerTs failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "getVerTs failed: unknown result"); } - public List getRow(ByteBuffer tableName, ByteBuffer row) throws IOError, org.apache.thrift.TException + public List getRow(ByteBuffer tableName, ByteBuffer row) throws IOError, TException { send_getRow(tableName, row); return recv_getRow(); } - public void send_getRow(ByteBuffer tableName, ByteBuffer row) throws org.apache.thrift.TException + public void send_getRow(ByteBuffer tableName, ByteBuffer row) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRow", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("getRow", TMessageType.CALL, ++seqid_)); getRow_args args = new getRow_args(); args.setTableName(tableName); args.setRow(row); @@ -1168,16 +1174,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public List recv_getRow() throws IOError, org.apache.thrift.TException + public List recv_getRow() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "getRow failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getRow failed: out of sequence response"); } getRow_result result = new getRow_result(); result.read(iprot_); @@ -1188,18 +1194,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRow failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRow failed: unknown result"); } - public List getRowWithColumns(ByteBuffer tableName, ByteBuffer row, List columns) throws IOError, org.apache.thrift.TException + public List getRowWithColumns(ByteBuffer tableName, ByteBuffer row, List columns) throws IOError, TException { send_getRowWithColumns(tableName, row, columns); return recv_getRowWithColumns(); } - public void send_getRowWithColumns(ByteBuffer tableName, ByteBuffer row, List columns) throws org.apache.thrift.TException + public void send_getRowWithColumns(ByteBuffer tableName, ByteBuffer row, List columns) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumns", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.CALL, ++seqid_)); getRowWithColumns_args args = new getRowWithColumns_args(); args.setTableName(tableName); args.setRow(row); @@ -1209,16 +1215,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public List recv_getRowWithColumns() throws IOError, org.apache.thrift.TException + public List recv_getRowWithColumns() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "getRowWithColumns failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getRowWithColumns failed: out of sequence response"); } getRowWithColumns_result result = new getRowWithColumns_result(); result.read(iprot_); @@ -1229,18 +1235,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRowWithColumns failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowWithColumns failed: unknown result"); } - public List getRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws IOError, org.apache.thrift.TException + public List getRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws IOError, TException { send_getRowTs(tableName, row, timestamp); return recv_getRowTs(); } - public void send_getRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws org.apache.thrift.TException + public void send_getRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowTs", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("getRowTs", TMessageType.CALL, ++seqid_)); getRowTs_args args = new getRowTs_args(); args.setTableName(tableName); args.setRow(row); @@ -1250,16 +1256,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public List recv_getRowTs() throws IOError, org.apache.thrift.TException + public List recv_getRowTs() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "getRowTs failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getRowTs failed: out of sequence response"); } getRowTs_result result = new getRowTs_result(); result.read(iprot_); @@ -1270,18 +1276,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRowTs failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowTs failed: unknown result"); } - public List getRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp) throws IOError, org.apache.thrift.TException + public List getRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp) throws IOError, TException { send_getRowWithColumnsTs(tableName, row, columns, timestamp); return recv_getRowWithColumnsTs(); } - public void send_getRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp) throws org.apache.thrift.TException + public void send_getRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumnsTs", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.CALL, ++seqid_)); getRowWithColumnsTs_args args = new getRowWithColumnsTs_args(); args.setTableName(tableName); args.setRow(row); @@ -1292,16 +1298,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public List recv_getRowWithColumnsTs() throws IOError, org.apache.thrift.TException + public List recv_getRowWithColumnsTs() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "getRowWithColumnsTs failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getRowWithColumnsTs failed: out of sequence response"); } getRowWithColumnsTs_result result = new getRowWithColumnsTs_result(); result.read(iprot_); @@ -1312,18 +1318,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRowWithColumnsTs failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowWithColumnsTs failed: unknown result"); } - public List getRows(ByteBuffer tableName, List rows) throws IOError, org.apache.thrift.TException + public List getRows(ByteBuffer tableName, List rows) throws IOError, TException { send_getRows(tableName, rows); return recv_getRows(); } - public void send_getRows(ByteBuffer tableName, List rows) throws org.apache.thrift.TException + public void send_getRows(ByteBuffer tableName, List rows) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRows", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("getRows", TMessageType.CALL, ++seqid_)); getRows_args args = new getRows_args(); args.setTableName(tableName); args.setRows(rows); @@ -1332,16 +1338,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public List recv_getRows() throws IOError, org.apache.thrift.TException + public List recv_getRows() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "getRows failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getRows failed: out of sequence response"); } getRows_result result = new getRows_result(); result.read(iprot_); @@ -1352,18 +1358,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRows failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRows failed: unknown result"); } - public List getRowsWithColumns(ByteBuffer tableName, List rows, List columns) throws IOError, org.apache.thrift.TException + public List getRowsWithColumns(ByteBuffer tableName, List rows, List columns) throws IOError, TException { send_getRowsWithColumns(tableName, rows, columns); return recv_getRowsWithColumns(); } - public void send_getRowsWithColumns(ByteBuffer tableName, List rows, List columns) throws org.apache.thrift.TException + public void send_getRowsWithColumns(ByteBuffer tableName, List rows, List columns) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowsWithColumns", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("getRowsWithColumns", TMessageType.CALL, ++seqid_)); getRowsWithColumns_args args = new getRowsWithColumns_args(); args.setTableName(tableName); args.setRows(rows); @@ -1373,16 +1379,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public List recv_getRowsWithColumns() throws IOError, org.apache.thrift.TException + public List recv_getRowsWithColumns() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "getRowsWithColumns failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getRowsWithColumns failed: out of sequence response"); } getRowsWithColumns_result result = new getRowsWithColumns_result(); result.read(iprot_); @@ -1393,18 +1399,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRowsWithColumns failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowsWithColumns failed: unknown result"); } - public List getRowsTs(ByteBuffer tableName, List rows, long timestamp) throws IOError, org.apache.thrift.TException + public List getRowsTs(ByteBuffer tableName, List rows, long timestamp) throws IOError, TException { send_getRowsTs(tableName, rows, timestamp); return recv_getRowsTs(); } - public void send_getRowsTs(ByteBuffer tableName, List rows, long timestamp) throws org.apache.thrift.TException + public void send_getRowsTs(ByteBuffer tableName, List rows, long timestamp) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowsTs", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("getRowsTs", TMessageType.CALL, ++seqid_)); getRowsTs_args args = new getRowsTs_args(); args.setTableName(tableName); args.setRows(rows); @@ -1414,16 +1420,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public List recv_getRowsTs() throws IOError, org.apache.thrift.TException + public List recv_getRowsTs() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "getRowsTs failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getRowsTs failed: out of sequence response"); } getRowsTs_result result = new getRowsTs_result(); result.read(iprot_); @@ -1434,18 +1440,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRowsTs failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowsTs failed: unknown result"); } - public List getRowsWithColumnsTs(ByteBuffer tableName, List rows, List columns, long timestamp) throws IOError, org.apache.thrift.TException + public List getRowsWithColumnsTs(ByteBuffer tableName, List rows, List columns, long timestamp) throws IOError, TException { send_getRowsWithColumnsTs(tableName, rows, columns, timestamp); return recv_getRowsWithColumnsTs(); } - public void send_getRowsWithColumnsTs(ByteBuffer tableName, List rows, List columns, long timestamp) throws org.apache.thrift.TException + public void send_getRowsWithColumnsTs(ByteBuffer tableName, List rows, List columns, long timestamp) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowsWithColumnsTs", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("getRowsWithColumnsTs", TMessageType.CALL, ++seqid_)); getRowsWithColumnsTs_args args = new getRowsWithColumnsTs_args(); args.setTableName(tableName); args.setRows(rows); @@ -1456,16 +1462,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public List recv_getRowsWithColumnsTs() throws IOError, org.apache.thrift.TException + public List recv_getRowsWithColumnsTs() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "getRowsWithColumnsTs failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getRowsWithColumnsTs failed: out of sequence response"); } getRowsWithColumnsTs_result result = new getRowsWithColumnsTs_result(); result.read(iprot_); @@ -1476,18 +1482,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRowsWithColumnsTs failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowsWithColumnsTs failed: unknown result"); } - public void mutateRow(ByteBuffer tableName, ByteBuffer row, List mutations) throws IOError, IllegalArgument, org.apache.thrift.TException + public void mutateRow(ByteBuffer tableName, ByteBuffer row, List mutations) throws IOError, IllegalArgument, TException { send_mutateRow(tableName, row, mutations); recv_mutateRow(); } - public void send_mutateRow(ByteBuffer tableName, ByteBuffer row, List mutations) throws org.apache.thrift.TException + public void send_mutateRow(ByteBuffer tableName, ByteBuffer row, List mutations) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRow", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("mutateRow", TMessageType.CALL, ++seqid_)); mutateRow_args args = new mutateRow_args(); args.setTableName(tableName); args.setRow(row); @@ -1497,16 +1503,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public void recv_mutateRow() throws IOError, IllegalArgument, org.apache.thrift.TException + public void recv_mutateRow() throws IOError, IllegalArgument, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "mutateRow failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "mutateRow failed: out of sequence response"); } mutateRow_result result = new mutateRow_result(); result.read(iprot_); @@ -1520,15 +1526,15 @@ public class Hbase { return; } - public void mutateRowTs(ByteBuffer tableName, ByteBuffer row, List mutations, long timestamp) throws IOError, IllegalArgument, org.apache.thrift.TException + public void mutateRowTs(ByteBuffer tableName, ByteBuffer row, List mutations, long timestamp) throws IOError, IllegalArgument, TException { send_mutateRowTs(tableName, row, mutations, timestamp); recv_mutateRowTs(); } - public void send_mutateRowTs(ByteBuffer tableName, ByteBuffer row, List mutations, long timestamp) throws org.apache.thrift.TException + public void send_mutateRowTs(ByteBuffer tableName, ByteBuffer row, List mutations, long timestamp) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRowTs", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.CALL, ++seqid_)); mutateRowTs_args args = new mutateRowTs_args(); args.setTableName(tableName); args.setRow(row); @@ -1539,16 +1545,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public void recv_mutateRowTs() throws IOError, IllegalArgument, org.apache.thrift.TException + public void recv_mutateRowTs() throws IOError, IllegalArgument, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "mutateRowTs failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "mutateRowTs failed: out of sequence response"); } mutateRowTs_result result = new mutateRowTs_result(); result.read(iprot_); @@ -1562,15 +1568,15 @@ public class Hbase { return; } - public void mutateRows(ByteBuffer tableName, List rowBatches) throws IOError, IllegalArgument, org.apache.thrift.TException + public void mutateRows(ByteBuffer tableName, List rowBatches) throws IOError, IllegalArgument, TException { send_mutateRows(tableName, rowBatches); recv_mutateRows(); } - public void send_mutateRows(ByteBuffer tableName, List rowBatches) throws org.apache.thrift.TException + public void send_mutateRows(ByteBuffer tableName, List rowBatches) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRows", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("mutateRows", TMessageType.CALL, ++seqid_)); mutateRows_args args = new mutateRows_args(); args.setTableName(tableName); args.setRowBatches(rowBatches); @@ -1579,16 +1585,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public void recv_mutateRows() throws IOError, IllegalArgument, org.apache.thrift.TException + public void recv_mutateRows() throws IOError, IllegalArgument, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "mutateRows failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "mutateRows failed: out of sequence response"); } mutateRows_result result = new mutateRows_result(); result.read(iprot_); @@ -1602,15 +1608,15 @@ public class Hbase { return; } - public void mutateRowsTs(ByteBuffer tableName, List rowBatches, long timestamp) throws IOError, IllegalArgument, org.apache.thrift.TException + public void mutateRowsTs(ByteBuffer tableName, List rowBatches, long timestamp) throws IOError, IllegalArgument, TException { send_mutateRowsTs(tableName, rowBatches, timestamp); recv_mutateRowsTs(); } - public void send_mutateRowsTs(ByteBuffer tableName, List rowBatches, long timestamp) throws org.apache.thrift.TException + public void send_mutateRowsTs(ByteBuffer tableName, List rowBatches, long timestamp) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRowsTs", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.CALL, ++seqid_)); mutateRowsTs_args args = new mutateRowsTs_args(); args.setTableName(tableName); args.setRowBatches(rowBatches); @@ -1620,16 +1626,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public void recv_mutateRowsTs() throws IOError, IllegalArgument, org.apache.thrift.TException + public void recv_mutateRowsTs() throws IOError, IllegalArgument, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "mutateRowsTs failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "mutateRowsTs failed: out of sequence response"); } mutateRowsTs_result result = new mutateRowsTs_result(); result.read(iprot_); @@ -1643,15 +1649,15 @@ public class Hbase { return; } - public long atomicIncrement(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long value) throws IOError, IllegalArgument, org.apache.thrift.TException + public long atomicIncrement(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long value) throws IOError, IllegalArgument, TException { send_atomicIncrement(tableName, row, column, value); return recv_atomicIncrement(); } - public void send_atomicIncrement(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long value) throws org.apache.thrift.TException + public void send_atomicIncrement(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long value) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("atomicIncrement", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.CALL, ++seqid_)); atomicIncrement_args args = new atomicIncrement_args(); args.setTableName(tableName); args.setRow(row); @@ -1662,16 +1668,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public long recv_atomicIncrement() throws IOError, IllegalArgument, org.apache.thrift.TException + public long recv_atomicIncrement() throws IOError, IllegalArgument, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "atomicIncrement failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "atomicIncrement failed: out of sequence response"); } atomicIncrement_result result = new atomicIncrement_result(); result.read(iprot_); @@ -1685,18 +1691,18 @@ public class Hbase { if (result.ia != null) { throw result.ia; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "atomicIncrement failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "atomicIncrement failed: unknown result"); } - public void deleteAll(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws IOError, org.apache.thrift.TException + public void deleteAll(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws IOError, TException { send_deleteAll(tableName, row, column); recv_deleteAll(); } - public void send_deleteAll(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws org.apache.thrift.TException + public void send_deleteAll(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAll", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("deleteAll", TMessageType.CALL, ++seqid_)); deleteAll_args args = new deleteAll_args(); args.setTableName(tableName); args.setRow(row); @@ -1706,16 +1712,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public void recv_deleteAll() throws IOError, org.apache.thrift.TException + public void recv_deleteAll() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "deleteAll failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "deleteAll failed: out of sequence response"); } deleteAll_result result = new deleteAll_result(); result.read(iprot_); @@ -1726,15 +1732,15 @@ public class Hbase { return; } - public void deleteAllTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp) throws IOError, org.apache.thrift.TException + public void deleteAllTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp) throws IOError, TException { send_deleteAllTs(tableName, row, column, timestamp); recv_deleteAllTs(); } - public void send_deleteAllTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp) throws org.apache.thrift.TException + public void send_deleteAllTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAllTs", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.CALL, ++seqid_)); deleteAllTs_args args = new deleteAllTs_args(); args.setTableName(tableName); args.setRow(row); @@ -1745,16 +1751,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public void recv_deleteAllTs() throws IOError, org.apache.thrift.TException + public void recv_deleteAllTs() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "deleteAllTs failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "deleteAllTs failed: out of sequence response"); } deleteAllTs_result result = new deleteAllTs_result(); result.read(iprot_); @@ -1765,15 +1771,15 @@ public class Hbase { return; } - public void deleteAllRow(ByteBuffer tableName, ByteBuffer row) throws IOError, org.apache.thrift.TException + public void deleteAllRow(ByteBuffer tableName, ByteBuffer row) throws IOError, TException { send_deleteAllRow(tableName, row); recv_deleteAllRow(); } - public void send_deleteAllRow(ByteBuffer tableName, ByteBuffer row) throws org.apache.thrift.TException + public void send_deleteAllRow(ByteBuffer tableName, ByteBuffer row) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAllRow", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.CALL, ++seqid_)); deleteAllRow_args args = new deleteAllRow_args(); args.setTableName(tableName); args.setRow(row); @@ -1782,16 +1788,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public void recv_deleteAllRow() throws IOError, org.apache.thrift.TException + public void recv_deleteAllRow() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "deleteAllRow failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "deleteAllRow failed: out of sequence response"); } deleteAllRow_result result = new deleteAllRow_result(); result.read(iprot_); @@ -1802,15 +1808,15 @@ public class Hbase { return; } - public void deleteAllRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws IOError, org.apache.thrift.TException + public void deleteAllRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws IOError, TException { send_deleteAllRowTs(tableName, row, timestamp); recv_deleteAllRowTs(); } - public void send_deleteAllRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws org.apache.thrift.TException + public void send_deleteAllRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAllRowTs", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.CALL, ++seqid_)); deleteAllRowTs_args args = new deleteAllRowTs_args(); args.setTableName(tableName); args.setRow(row); @@ -1820,16 +1826,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public void recv_deleteAllRowTs() throws IOError, org.apache.thrift.TException + public void recv_deleteAllRowTs() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "deleteAllRowTs failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "deleteAllRowTs failed: out of sequence response"); } deleteAllRowTs_result result = new deleteAllRowTs_result(); result.read(iprot_); @@ -1840,15 +1846,15 @@ public class Hbase { return; } - public int scannerOpenWithScan(ByteBuffer tableName, TScan scan) throws IOError, org.apache.thrift.TException + public int scannerOpenWithScan(ByteBuffer tableName, TScan scan) throws IOError, TException { send_scannerOpenWithScan(tableName, scan); return recv_scannerOpenWithScan(); } - public void send_scannerOpenWithScan(ByteBuffer tableName, TScan scan) throws org.apache.thrift.TException + public void send_scannerOpenWithScan(ByteBuffer tableName, TScan scan) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithScan", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("scannerOpenWithScan", TMessageType.CALL, ++seqid_)); scannerOpenWithScan_args args = new scannerOpenWithScan_args(); args.setTableName(tableName); args.setScan(scan); @@ -1857,16 +1863,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public int recv_scannerOpenWithScan() throws IOError, org.apache.thrift.TException + public int recv_scannerOpenWithScan() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "scannerOpenWithScan failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "scannerOpenWithScan failed: out of sequence response"); } scannerOpenWithScan_result result = new scannerOpenWithScan_result(); result.read(iprot_); @@ -1877,18 +1883,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "scannerOpenWithScan failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithScan failed: unknown result"); } - public int scannerOpen(ByteBuffer tableName, ByteBuffer startRow, List columns) throws IOError, org.apache.thrift.TException + public int scannerOpen(ByteBuffer tableName, ByteBuffer startRow, List columns) throws IOError, TException { send_scannerOpen(tableName, startRow, columns); return recv_scannerOpen(); } - public void send_scannerOpen(ByteBuffer tableName, ByteBuffer startRow, List columns) throws org.apache.thrift.TException + public void send_scannerOpen(ByteBuffer tableName, ByteBuffer startRow, List columns) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpen", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("scannerOpen", TMessageType.CALL, ++seqid_)); scannerOpen_args args = new scannerOpen_args(); args.setTableName(tableName); args.setStartRow(startRow); @@ -1898,16 +1904,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public int recv_scannerOpen() throws IOError, org.apache.thrift.TException + public int recv_scannerOpen() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "scannerOpen failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "scannerOpen failed: out of sequence response"); } scannerOpen_result result = new scannerOpen_result(); result.read(iprot_); @@ -1918,18 +1924,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "scannerOpen failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpen failed: unknown result"); } - public int scannerOpenWithStop(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns) throws IOError, org.apache.thrift.TException + public int scannerOpenWithStop(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns) throws IOError, TException { send_scannerOpenWithStop(tableName, startRow, stopRow, columns); return recv_scannerOpenWithStop(); } - public void send_scannerOpenWithStop(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns) throws org.apache.thrift.TException + public void send_scannerOpenWithStop(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithStop", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.CALL, ++seqid_)); scannerOpenWithStop_args args = new scannerOpenWithStop_args(); args.setTableName(tableName); args.setStartRow(startRow); @@ -1940,16 +1946,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public int recv_scannerOpenWithStop() throws IOError, org.apache.thrift.TException + public int recv_scannerOpenWithStop() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "scannerOpenWithStop failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "scannerOpenWithStop failed: out of sequence response"); } scannerOpenWithStop_result result = new scannerOpenWithStop_result(); result.read(iprot_); @@ -1960,18 +1966,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "scannerOpenWithStop failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithStop failed: unknown result"); } - public int scannerOpenWithPrefix(ByteBuffer tableName, ByteBuffer startAndPrefix, List columns) throws IOError, org.apache.thrift.TException + public int scannerOpenWithPrefix(ByteBuffer tableName, ByteBuffer startAndPrefix, List columns) throws IOError, TException { send_scannerOpenWithPrefix(tableName, startAndPrefix, columns); return recv_scannerOpenWithPrefix(); } - public void send_scannerOpenWithPrefix(ByteBuffer tableName, ByteBuffer startAndPrefix, List columns) throws org.apache.thrift.TException + public void send_scannerOpenWithPrefix(ByteBuffer tableName, ByteBuffer startAndPrefix, List columns) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithPrefix", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.CALL, ++seqid_)); scannerOpenWithPrefix_args args = new scannerOpenWithPrefix_args(); args.setTableName(tableName); args.setStartAndPrefix(startAndPrefix); @@ -1981,16 +1987,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public int recv_scannerOpenWithPrefix() throws IOError, org.apache.thrift.TException + public int recv_scannerOpenWithPrefix() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "scannerOpenWithPrefix failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "scannerOpenWithPrefix failed: out of sequence response"); } scannerOpenWithPrefix_result result = new scannerOpenWithPrefix_result(); result.read(iprot_); @@ -2001,18 +2007,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "scannerOpenWithPrefix failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithPrefix failed: unknown result"); } - public int scannerOpenTs(ByteBuffer tableName, ByteBuffer startRow, List columns, long timestamp) throws IOError, org.apache.thrift.TException + public int scannerOpenTs(ByteBuffer tableName, ByteBuffer startRow, List columns, long timestamp) throws IOError, TException { send_scannerOpenTs(tableName, startRow, columns, timestamp); return recv_scannerOpenTs(); } - public void send_scannerOpenTs(ByteBuffer tableName, ByteBuffer startRow, List columns, long timestamp) throws org.apache.thrift.TException + public void send_scannerOpenTs(ByteBuffer tableName, ByteBuffer startRow, List columns, long timestamp) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenTs", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.CALL, ++seqid_)); scannerOpenTs_args args = new scannerOpenTs_args(); args.setTableName(tableName); args.setStartRow(startRow); @@ -2023,16 +2029,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public int recv_scannerOpenTs() throws IOError, org.apache.thrift.TException + public int recv_scannerOpenTs() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "scannerOpenTs failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "scannerOpenTs failed: out of sequence response"); } scannerOpenTs_result result = new scannerOpenTs_result(); result.read(iprot_); @@ -2043,18 +2049,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "scannerOpenTs failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenTs failed: unknown result"); } - public int scannerOpenWithStopTs(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns, long timestamp) throws IOError, org.apache.thrift.TException + public int scannerOpenWithStopTs(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns, long timestamp) throws IOError, TException { send_scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp); return recv_scannerOpenWithStopTs(); } - public void send_scannerOpenWithStopTs(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns, long timestamp) throws org.apache.thrift.TException + public void send_scannerOpenWithStopTs(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns, long timestamp) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithStopTs", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.CALL, ++seqid_)); scannerOpenWithStopTs_args args = new scannerOpenWithStopTs_args(); args.setTableName(tableName); args.setStartRow(startRow); @@ -2066,16 +2072,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public int recv_scannerOpenWithStopTs() throws IOError, org.apache.thrift.TException + public int recv_scannerOpenWithStopTs() throws IOError, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "scannerOpenWithStopTs failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "scannerOpenWithStopTs failed: out of sequence response"); } scannerOpenWithStopTs_result result = new scannerOpenWithStopTs_result(); result.read(iprot_); @@ -2086,18 +2092,18 @@ public class Hbase { if (result.io != null) { throw result.io; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "scannerOpenWithStopTs failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithStopTs failed: unknown result"); } - public List scannerGet(int id) throws IOError, IllegalArgument, org.apache.thrift.TException + public List scannerGet(int id) throws IOError, IllegalArgument, TException { send_scannerGet(id); return recv_scannerGet(); } - public void send_scannerGet(int id) throws org.apache.thrift.TException + public void send_scannerGet(int id) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerGet", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("scannerGet", TMessageType.CALL, ++seqid_)); scannerGet_args args = new scannerGet_args(); args.setId(id); args.write(oprot_); @@ -2105,16 +2111,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public List recv_scannerGet() throws IOError, IllegalArgument, org.apache.thrift.TException + public List recv_scannerGet() throws IOError, IllegalArgument, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "scannerGet failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "scannerGet failed: out of sequence response"); } scannerGet_result result = new scannerGet_result(); result.read(iprot_); @@ -2128,18 +2134,18 @@ public class Hbase { if (result.ia != null) { throw result.ia; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "scannerGet failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerGet failed: unknown result"); } - public List scannerGetList(int id, int nbRows) throws IOError, IllegalArgument, org.apache.thrift.TException + public List scannerGetList(int id, int nbRows) throws IOError, IllegalArgument, TException { send_scannerGetList(id, nbRows); return recv_scannerGetList(); } - public void send_scannerGetList(int id, int nbRows) throws org.apache.thrift.TException + public void send_scannerGetList(int id, int nbRows) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerGetList", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("scannerGetList", TMessageType.CALL, ++seqid_)); scannerGetList_args args = new scannerGetList_args(); args.setId(id); args.setNbRows(nbRows); @@ -2148,16 +2154,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public List recv_scannerGetList() throws IOError, IllegalArgument, org.apache.thrift.TException + public List recv_scannerGetList() throws IOError, IllegalArgument, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "scannerGetList failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "scannerGetList failed: out of sequence response"); } scannerGetList_result result = new scannerGetList_result(); result.read(iprot_); @@ -2171,18 +2177,18 @@ public class Hbase { if (result.ia != null) { throw result.ia; } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "scannerGetList failed: unknown result"); + throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerGetList failed: unknown result"); } - public void scannerClose(int id) throws IOError, IllegalArgument, org.apache.thrift.TException + public void scannerClose(int id) throws IOError, IllegalArgument, TException { send_scannerClose(id); recv_scannerClose(); } - public void send_scannerClose(int id) throws org.apache.thrift.TException + public void send_scannerClose(int id) throws TException { - oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerClose", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + oprot_.writeMessageBegin(new TMessage("scannerClose", TMessageType.CALL, ++seqid_)); scannerClose_args args = new scannerClose_args(); args.setId(id); args.write(oprot_); @@ -2190,16 +2196,16 @@ public class Hbase { oprot_.getTransport().flush(); } - public void recv_scannerClose() throws IOError, IllegalArgument, org.apache.thrift.TException + public void recv_scannerClose() throws IOError, IllegalArgument, TException { - org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); - if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { - org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + TMessage msg = iprot_.readMessageBegin(); + if (msg.type == TMessageType.EXCEPTION) { + TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "scannerClose failed: out of sequence response"); + throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "scannerClose failed: out of sequence response"); } scannerClose_result result = new scannerClose_result(); result.read(iprot_); @@ -2214,294 +2220,285 @@ public class Hbase { } } - public static class AsyncClient extends org.apache.thrift.async.TAsyncClient implements AsyncIface { - public static class Factory implements org.apache.thrift.async.TAsyncClientFactory { - private org.apache.thrift.async.TAsyncClientManager clientManager; - private org.apache.thrift.protocol.TProtocolFactory protocolFactory; - public Factory(org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.protocol.TProtocolFactory protocolFactory) { + public static class AsyncClient extends TAsyncClient implements AsyncIface { + public static class Factory implements TAsyncClientFactory { + private TAsyncClientManager clientManager; + private TProtocolFactory protocolFactory; + public Factory(TAsyncClientManager clientManager, TProtocolFactory protocolFactory) { this.clientManager = clientManager; this.protocolFactory = protocolFactory; } - public AsyncClient getAsyncClient(org.apache.thrift.transport.TNonblockingTransport transport) { + public AsyncClient getAsyncClient(TNonblockingTransport transport) { return new AsyncClient(protocolFactory, clientManager, transport); } } - public AsyncClient(org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.transport.TNonblockingTransport transport) { + public AsyncClient(TProtocolFactory protocolFactory, TAsyncClientManager clientManager, TNonblockingTransport transport) { super(protocolFactory, clientManager, transport); } - public void enableTable(ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void enableTable(ByteBuffer tableName, AsyncMethodCallback resultHandler) throws TException { checkReady(); enableTable_call method_call = new enableTable_call(tableName, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class enableTable_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class enableTable_call extends TAsyncMethodCall { private ByteBuffer tableName; - public enableTable_call(ByteBuffer tableName, 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 { + public enableTable_call(ByteBuffer tableName, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("enableTable", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("enableTable", TMessageType.CALL, 0)); enableTable_args args = new enableTable_args(); args.setTableName(tableName); args.write(prot); prot.writeMessageEnd(); } - public void getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public void getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); (new Client(prot)).recv_enableTable(); } } - public void disableTable(ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void disableTable(ByteBuffer tableName, AsyncMethodCallback resultHandler) throws TException { checkReady(); disableTable_call method_call = new disableTable_call(tableName, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class disableTable_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class disableTable_call extends TAsyncMethodCall { private ByteBuffer tableName; - public disableTable_call(ByteBuffer tableName, 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 { + public disableTable_call(ByteBuffer tableName, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("disableTable", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("disableTable", TMessageType.CALL, 0)); disableTable_args args = new disableTable_args(); args.setTableName(tableName); args.write(prot); prot.writeMessageEnd(); } - public void getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public void getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); (new Client(prot)).recv_disableTable(); } } - public void isTableEnabled(ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void isTableEnabled(ByteBuffer tableName, AsyncMethodCallback resultHandler) throws TException { checkReady(); isTableEnabled_call method_call = new isTableEnabled_call(tableName, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class isTableEnabled_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class isTableEnabled_call extends TAsyncMethodCall { private ByteBuffer tableName; - public isTableEnabled_call(ByteBuffer tableName, 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 { + public isTableEnabled_call(ByteBuffer tableName, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("isTableEnabled", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.CALL, 0)); isTableEnabled_args args = new isTableEnabled_args(); args.setTableName(tableName); args.write(prot); prot.writeMessageEnd(); } - public boolean getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public boolean getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_isTableEnabled(); } } - public void compact(ByteBuffer tableNameOrRegionName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void compact(ByteBuffer tableNameOrRegionName, AsyncMethodCallback resultHandler) throws TException { checkReady(); compact_call method_call = new compact_call(tableNameOrRegionName, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class compact_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class compact_call extends TAsyncMethodCall { private ByteBuffer tableNameOrRegionName; - public compact_call(ByteBuffer tableNameOrRegionName, 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 { + public compact_call(ByteBuffer tableNameOrRegionName, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableNameOrRegionName = tableNameOrRegionName; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("compact", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("compact", TMessageType.CALL, 0)); compact_args args = new compact_args(); args.setTableNameOrRegionName(tableNameOrRegionName); args.write(prot); prot.writeMessageEnd(); } - public void getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public void getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); (new Client(prot)).recv_compact(); } } - public void majorCompact(ByteBuffer tableNameOrRegionName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void majorCompact(ByteBuffer tableNameOrRegionName, AsyncMethodCallback resultHandler) throws TException { checkReady(); majorCompact_call method_call = new majorCompact_call(tableNameOrRegionName, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class majorCompact_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class majorCompact_call extends TAsyncMethodCall { private ByteBuffer tableNameOrRegionName; - public majorCompact_call(ByteBuffer tableNameOrRegionName, 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 { + public majorCompact_call(ByteBuffer tableNameOrRegionName, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableNameOrRegionName = tableNameOrRegionName; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("majorCompact", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("majorCompact", TMessageType.CALL, 0)); majorCompact_args args = new majorCompact_args(); args.setTableNameOrRegionName(tableNameOrRegionName); args.write(prot); prot.writeMessageEnd(); } - public void getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public void getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); (new Client(prot)).recv_majorCompact(); } } - public void getTableNames(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void getTableNames(AsyncMethodCallback resultHandler) throws TException { checkReady(); getTableNames_call method_call = new getTableNames_call(resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class getTableNames_call extends org.apache.thrift.async.TAsyncMethodCall { - public getTableNames_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 { + public static class getTableNames_call extends TAsyncMethodCall { + public getTableNames_call(AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws 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("getTableNames", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("getTableNames", TMessageType.CALL, 0)); getTableNames_args args = new getTableNames_args(); args.write(prot); prot.writeMessageEnd(); } - public List getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public List getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_getTableNames(); } } - public void getColumnDescriptors(ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void getColumnDescriptors(ByteBuffer tableName, AsyncMethodCallback resultHandler) throws TException { checkReady(); getColumnDescriptors_call method_call = new getColumnDescriptors_call(tableName, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class getColumnDescriptors_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class getColumnDescriptors_call extends TAsyncMethodCall { private ByteBuffer tableName; - public getColumnDescriptors_call(ByteBuffer tableName, 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 { + public getColumnDescriptors_call(ByteBuffer tableName, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getColumnDescriptors", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.CALL, 0)); getColumnDescriptors_args args = new getColumnDescriptors_args(); args.setTableName(tableName); args.write(prot); prot.writeMessageEnd(); } - public Map getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public Map getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_getColumnDescriptors(); } } - public void getTableRegions(ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void getTableRegions(ByteBuffer tableName, AsyncMethodCallback resultHandler) throws TException { checkReady(); getTableRegions_call method_call = new getTableRegions_call(tableName, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class getTableRegions_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class getTableRegions_call extends TAsyncMethodCall { private ByteBuffer tableName; - public getTableRegions_call(ByteBuffer tableName, 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 { + public getTableRegions_call(ByteBuffer tableName, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTableRegions", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("getTableRegions", TMessageType.CALL, 0)); getTableRegions_args args = new getTableRegions_args(); args.setTableName(tableName); args.write(prot); prot.writeMessageEnd(); } - public List getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public List getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_getTableRegions(); } } - public void createTable(ByteBuffer tableName, List columnFamilies, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void createTable(ByteBuffer tableName, List columnFamilies, AsyncMethodCallback resultHandler) throws TException { checkReady(); createTable_call method_call = new createTable_call(tableName, columnFamilies, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class createTable_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class createTable_call extends TAsyncMethodCall { private ByteBuffer tableName; private List columnFamilies; - public createTable_call(ByteBuffer tableName, List columnFamilies, 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 { + public createTable_call(ByteBuffer tableName, List columnFamilies, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.columnFamilies = columnFamilies; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("createTable", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("createTable", TMessageType.CALL, 0)); createTable_args args = new createTable_args(); args.setTableName(tableName); args.setColumnFamilies(columnFamilies); @@ -2509,68 +2506,66 @@ public class Hbase { prot.writeMessageEnd(); } - public void getResult() throws IOError, IllegalArgument, AlreadyExists, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public void getResult() throws IOError, IllegalArgument, AlreadyExists, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); (new Client(prot)).recv_createTable(); } } - public void deleteTable(ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void deleteTable(ByteBuffer tableName, AsyncMethodCallback resultHandler) throws TException { checkReady(); deleteTable_call method_call = new deleteTable_call(tableName, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class deleteTable_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class deleteTable_call extends TAsyncMethodCall { private ByteBuffer tableName; - public deleteTable_call(ByteBuffer tableName, 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 { + public deleteTable_call(ByteBuffer tableName, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteTable", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("deleteTable", TMessageType.CALL, 0)); deleteTable_args args = new deleteTable_args(); args.setTableName(tableName); args.write(prot); prot.writeMessageEnd(); } - public void getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public void getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); (new Client(prot)).recv_deleteTable(); } } - public void get(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void get(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, AsyncMethodCallback resultHandler) throws TException { checkReady(); get_call method_call = new get_call(tableName, row, column, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class get_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class get_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer row; private ByteBuffer column; - public get_call(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, 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 { + public get_call(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.row = row; this.column = column; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("get", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("get", TMessageType.CALL, 0)); get_args args = new get_args(); args.setTableName(tableName); args.setRow(row); @@ -2579,29 +2574,28 @@ public class Hbase { prot.writeMessageEnd(); } - public List getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public List getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_get(); } } - public void getVer(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, int numVersions, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void getVer(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, int numVersions, AsyncMethodCallback resultHandler) throws TException { checkReady(); getVer_call method_call = new getVer_call(tableName, row, column, numVersions, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class getVer_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class getVer_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer row; private ByteBuffer column; private int numVersions; - public getVer_call(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, int numVersions, 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 { + public getVer_call(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, int numVersions, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.row = row; @@ -2609,8 +2603,8 @@ public class Hbase { this.numVersions = numVersions; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getVer", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("getVer", TMessageType.CALL, 0)); getVer_args args = new getVer_args(); args.setTableName(tableName); args.setRow(row); @@ -2620,30 +2614,29 @@ public class Hbase { prot.writeMessageEnd(); } - public List getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public List getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_getVer(); } } - public void getVerTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, int numVersions, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void getVerTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, int numVersions, AsyncMethodCallback resultHandler) throws TException { checkReady(); getVerTs_call method_call = new getVerTs_call(tableName, row, column, timestamp, numVersions, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class getVerTs_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class getVerTs_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer row; private ByteBuffer column; private long timestamp; private int numVersions; - public getVerTs_call(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, int numVersions, 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 { + public getVerTs_call(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, int numVersions, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.row = row; @@ -2652,8 +2645,8 @@ public class Hbase { this.numVersions = numVersions; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getVerTs", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("getVerTs", TMessageType.CALL, 0)); getVerTs_args args = new getVerTs_args(); args.setTableName(tableName); args.setRow(row); @@ -2664,34 +2657,33 @@ public class Hbase { prot.writeMessageEnd(); } - public List getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public List getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_getVerTs(); } } - public void getRow(ByteBuffer tableName, ByteBuffer row, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void getRow(ByteBuffer tableName, ByteBuffer row, AsyncMethodCallback resultHandler) throws TException { checkReady(); getRow_call method_call = new getRow_call(tableName, row, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class getRow_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class getRow_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer row; - public getRow_call(ByteBuffer tableName, ByteBuffer row, 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 { + public getRow_call(ByteBuffer tableName, ByteBuffer row, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.row = row; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRow", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("getRow", TMessageType.CALL, 0)); getRow_args args = new getRow_args(); args.setTableName(tableName); args.setRow(row); @@ -2699,36 +2691,35 @@ public class Hbase { prot.writeMessageEnd(); } - public List getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public List getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_getRow(); } } - public void getRowWithColumns(ByteBuffer tableName, ByteBuffer row, List columns, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void getRowWithColumns(ByteBuffer tableName, ByteBuffer row, List columns, AsyncMethodCallback resultHandler) throws TException { checkReady(); getRowWithColumns_call method_call = new getRowWithColumns_call(tableName, row, columns, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class getRowWithColumns_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class getRowWithColumns_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer row; private List columns; - public getRowWithColumns_call(ByteBuffer tableName, ByteBuffer row, List columns, 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 { + public getRowWithColumns_call(ByteBuffer tableName, ByteBuffer row, List columns, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.row = row; this.columns = columns; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumns", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.CALL, 0)); getRowWithColumns_args args = new getRowWithColumns_args(); args.setTableName(tableName); args.setRow(row); @@ -2737,36 +2728,35 @@ public class Hbase { prot.writeMessageEnd(); } - public List getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public List getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_getRowWithColumns(); } } - public void getRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void getRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp, AsyncMethodCallback resultHandler) throws TException { checkReady(); getRowTs_call method_call = new getRowTs_call(tableName, row, timestamp, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class getRowTs_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class getRowTs_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer row; private long timestamp; - public getRowTs_call(ByteBuffer tableName, ByteBuffer row, long timestamp, 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 { + public getRowTs_call(ByteBuffer tableName, ByteBuffer row, long timestamp, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.row = row; this.timestamp = timestamp; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowTs", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("getRowTs", TMessageType.CALL, 0)); getRowTs_args args = new getRowTs_args(); args.setTableName(tableName); args.setRow(row); @@ -2775,29 +2765,28 @@ public class Hbase { prot.writeMessageEnd(); } - public List getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public List getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_getRowTs(); } } - public void getRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void getRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp, AsyncMethodCallback resultHandler) throws TException { checkReady(); getRowWithColumnsTs_call method_call = new getRowWithColumnsTs_call(tableName, row, columns, timestamp, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class getRowWithColumnsTs_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class getRowWithColumnsTs_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer row; private List columns; private long timestamp; - public getRowWithColumnsTs_call(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp, 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 { + public getRowWithColumnsTs_call(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.row = row; @@ -2805,8 +2794,8 @@ public class Hbase { this.timestamp = timestamp; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumnsTs", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.CALL, 0)); getRowWithColumnsTs_args args = new getRowWithColumnsTs_args(); args.setTableName(tableName); args.setRow(row); @@ -2816,34 +2805,33 @@ public class Hbase { prot.writeMessageEnd(); } - public List getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public List getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_getRowWithColumnsTs(); } } - public void getRows(ByteBuffer tableName, List rows, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void getRows(ByteBuffer tableName, List rows, AsyncMethodCallback resultHandler) throws TException { checkReady(); getRows_call method_call = new getRows_call(tableName, rows, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class getRows_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class getRows_call extends TAsyncMethodCall { private ByteBuffer tableName; private List rows; - public getRows_call(ByteBuffer tableName, List rows, 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 { + public getRows_call(ByteBuffer tableName, List rows, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.rows = rows; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRows", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("getRows", TMessageType.CALL, 0)); getRows_args args = new getRows_args(); args.setTableName(tableName); args.setRows(rows); @@ -2851,36 +2839,35 @@ public class Hbase { prot.writeMessageEnd(); } - public List getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public List getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_getRows(); } } - public void getRowsWithColumns(ByteBuffer tableName, List rows, List columns, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void getRowsWithColumns(ByteBuffer tableName, List rows, List columns, AsyncMethodCallback resultHandler) throws TException { checkReady(); getRowsWithColumns_call method_call = new getRowsWithColumns_call(tableName, rows, columns, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class getRowsWithColumns_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class getRowsWithColumns_call extends TAsyncMethodCall { private ByteBuffer tableName; private List rows; private List columns; - public getRowsWithColumns_call(ByteBuffer tableName, List rows, List columns, 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 { + public getRowsWithColumns_call(ByteBuffer tableName, List rows, List columns, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.rows = rows; this.columns = columns; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowsWithColumns", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("getRowsWithColumns", TMessageType.CALL, 0)); getRowsWithColumns_args args = new getRowsWithColumns_args(); args.setTableName(tableName); args.setRows(rows); @@ -2889,36 +2876,35 @@ public class Hbase { prot.writeMessageEnd(); } - public List getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public List getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_getRowsWithColumns(); } } - public void getRowsTs(ByteBuffer tableName, List rows, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void getRowsTs(ByteBuffer tableName, List rows, long timestamp, AsyncMethodCallback resultHandler) throws TException { checkReady(); getRowsTs_call method_call = new getRowsTs_call(tableName, rows, timestamp, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class getRowsTs_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class getRowsTs_call extends TAsyncMethodCall { private ByteBuffer tableName; private List rows; private long timestamp; - public getRowsTs_call(ByteBuffer tableName, List rows, long timestamp, 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 { + public getRowsTs_call(ByteBuffer tableName, List rows, long timestamp, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.rows = rows; this.timestamp = timestamp; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowsTs", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("getRowsTs", TMessageType.CALL, 0)); getRowsTs_args args = new getRowsTs_args(); args.setTableName(tableName); args.setRows(rows); @@ -2927,29 +2913,28 @@ public class Hbase { prot.writeMessageEnd(); } - public List getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public List getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_getRowsTs(); } } - public void getRowsWithColumnsTs(ByteBuffer tableName, List rows, List columns, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void getRowsWithColumnsTs(ByteBuffer tableName, List rows, List columns, long timestamp, AsyncMethodCallback resultHandler) throws TException { checkReady(); getRowsWithColumnsTs_call method_call = new getRowsWithColumnsTs_call(tableName, rows, columns, timestamp, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class getRowsWithColumnsTs_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class getRowsWithColumnsTs_call extends TAsyncMethodCall { private ByteBuffer tableName; private List rows; private List columns; private long timestamp; - public getRowsWithColumnsTs_call(ByteBuffer tableName, List rows, List columns, long timestamp, 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 { + public getRowsWithColumnsTs_call(ByteBuffer tableName, List rows, List columns, long timestamp, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.rows = rows; @@ -2957,8 +2942,8 @@ public class Hbase { this.timestamp = timestamp; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowsWithColumnsTs", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("getRowsWithColumnsTs", TMessageType.CALL, 0)); getRowsWithColumnsTs_args args = new getRowsWithColumnsTs_args(); args.setTableName(tableName); args.setRows(rows); @@ -2968,36 +2953,35 @@ public class Hbase { prot.writeMessageEnd(); } - public List getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public List getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_getRowsWithColumnsTs(); } } - public void mutateRow(ByteBuffer tableName, ByteBuffer row, List mutations, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void mutateRow(ByteBuffer tableName, ByteBuffer row, List mutations, AsyncMethodCallback resultHandler) throws TException { checkReady(); mutateRow_call method_call = new mutateRow_call(tableName, row, mutations, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class mutateRow_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class mutateRow_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer row; private List mutations; - public mutateRow_call(ByteBuffer tableName, ByteBuffer row, List mutations, 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 { + public mutateRow_call(ByteBuffer tableName, ByteBuffer row, List mutations, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.row = row; this.mutations = mutations; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRow", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("mutateRow", TMessageType.CALL, 0)); mutateRow_args args = new mutateRow_args(); args.setTableName(tableName); args.setRow(row); @@ -3006,29 +2990,28 @@ public class Hbase { prot.writeMessageEnd(); } - public void getResult() throws IOError, IllegalArgument, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public void getResult() throws IOError, IllegalArgument, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); (new Client(prot)).recv_mutateRow(); } } - public void mutateRowTs(ByteBuffer tableName, ByteBuffer row, List mutations, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void mutateRowTs(ByteBuffer tableName, ByteBuffer row, List mutations, long timestamp, AsyncMethodCallback resultHandler) throws TException { checkReady(); mutateRowTs_call method_call = new mutateRowTs_call(tableName, row, mutations, timestamp, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class mutateRowTs_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class mutateRowTs_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer row; private List mutations; private long timestamp; - public mutateRowTs_call(ByteBuffer tableName, ByteBuffer row, List mutations, long timestamp, 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 { + public mutateRowTs_call(ByteBuffer tableName, ByteBuffer row, List mutations, long timestamp, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.row = row; @@ -3036,8 +3019,8 @@ public class Hbase { this.timestamp = timestamp; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRowTs", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.CALL, 0)); mutateRowTs_args args = new mutateRowTs_args(); args.setTableName(tableName); args.setRow(row); @@ -3047,34 +3030,33 @@ public class Hbase { prot.writeMessageEnd(); } - public void getResult() throws IOError, IllegalArgument, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public void getResult() throws IOError, IllegalArgument, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); (new Client(prot)).recv_mutateRowTs(); } } - public void mutateRows(ByteBuffer tableName, List rowBatches, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void mutateRows(ByteBuffer tableName, List rowBatches, AsyncMethodCallback resultHandler) throws TException { checkReady(); mutateRows_call method_call = new mutateRows_call(tableName, rowBatches, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class mutateRows_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class mutateRows_call extends TAsyncMethodCall { private ByteBuffer tableName; private List rowBatches; - public mutateRows_call(ByteBuffer tableName, List rowBatches, 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 { + public mutateRows_call(ByteBuffer tableName, List rowBatches, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.rowBatches = rowBatches; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRows", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("mutateRows", TMessageType.CALL, 0)); mutateRows_args args = new mutateRows_args(); args.setTableName(tableName); args.setRowBatches(rowBatches); @@ -3082,36 +3064,35 @@ public class Hbase { prot.writeMessageEnd(); } - public void getResult() throws IOError, IllegalArgument, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public void getResult() throws IOError, IllegalArgument, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); (new Client(prot)).recv_mutateRows(); } } - public void mutateRowsTs(ByteBuffer tableName, List rowBatches, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void mutateRowsTs(ByteBuffer tableName, List rowBatches, long timestamp, AsyncMethodCallback resultHandler) throws TException { checkReady(); mutateRowsTs_call method_call = new mutateRowsTs_call(tableName, rowBatches, timestamp, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class mutateRowsTs_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class mutateRowsTs_call extends TAsyncMethodCall { private ByteBuffer tableName; private List rowBatches; private long timestamp; - public mutateRowsTs_call(ByteBuffer tableName, List rowBatches, long timestamp, 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 { + public mutateRowsTs_call(ByteBuffer tableName, List rowBatches, long timestamp, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.rowBatches = rowBatches; this.timestamp = timestamp; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRowsTs", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.CALL, 0)); mutateRowsTs_args args = new mutateRowsTs_args(); args.setTableName(tableName); args.setRowBatches(rowBatches); @@ -3120,29 +3101,28 @@ public class Hbase { prot.writeMessageEnd(); } - public void getResult() throws IOError, IllegalArgument, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public void getResult() throws IOError, IllegalArgument, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); (new Client(prot)).recv_mutateRowsTs(); } } - public void atomicIncrement(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long value, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void atomicIncrement(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long value, AsyncMethodCallback resultHandler) throws TException { checkReady(); atomicIncrement_call method_call = new atomicIncrement_call(tableName, row, column, value, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class atomicIncrement_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class atomicIncrement_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer row; private ByteBuffer column; private long value; - public atomicIncrement_call(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long value, 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 { + public atomicIncrement_call(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long value, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.row = row; @@ -3150,8 +3130,8 @@ public class Hbase { this.value = value; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("atomicIncrement", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.CALL, 0)); atomicIncrement_args args = new atomicIncrement_args(); args.setTableName(tableName); args.setRow(row); @@ -3161,36 +3141,35 @@ public class Hbase { prot.writeMessageEnd(); } - public long getResult() throws IOError, IllegalArgument, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public long getResult() throws IOError, IllegalArgument, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_atomicIncrement(); } } - public void deleteAll(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void deleteAll(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, AsyncMethodCallback resultHandler) throws TException { checkReady(); deleteAll_call method_call = new deleteAll_call(tableName, row, column, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class deleteAll_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class deleteAll_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer row; private ByteBuffer column; - public deleteAll_call(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, 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 { + public deleteAll_call(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.row = row; this.column = column; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAll", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("deleteAll", TMessageType.CALL, 0)); deleteAll_args args = new deleteAll_args(); args.setTableName(tableName); args.setRow(row); @@ -3199,29 +3178,28 @@ public class Hbase { prot.writeMessageEnd(); } - public void getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public void getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); (new Client(prot)).recv_deleteAll(); } } - public void deleteAllTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void deleteAllTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, AsyncMethodCallback resultHandler) throws TException { checkReady(); deleteAllTs_call method_call = new deleteAllTs_call(tableName, row, column, timestamp, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class deleteAllTs_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class deleteAllTs_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer row; private ByteBuffer column; private long timestamp; - public deleteAllTs_call(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, 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 { + public deleteAllTs_call(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.row = row; @@ -3229,8 +3207,8 @@ public class Hbase { this.timestamp = timestamp; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAllTs", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.CALL, 0)); deleteAllTs_args args = new deleteAllTs_args(); args.setTableName(tableName); args.setRow(row); @@ -3240,34 +3218,33 @@ public class Hbase { prot.writeMessageEnd(); } - public void getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public void getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); (new Client(prot)).recv_deleteAllTs(); } } - public void deleteAllRow(ByteBuffer tableName, ByteBuffer row, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void deleteAllRow(ByteBuffer tableName, ByteBuffer row, AsyncMethodCallback resultHandler) throws TException { checkReady(); deleteAllRow_call method_call = new deleteAllRow_call(tableName, row, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class deleteAllRow_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class deleteAllRow_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer row; - public deleteAllRow_call(ByteBuffer tableName, ByteBuffer row, 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 { + public deleteAllRow_call(ByteBuffer tableName, ByteBuffer row, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.row = row; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAllRow", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.CALL, 0)); deleteAllRow_args args = new deleteAllRow_args(); args.setTableName(tableName); args.setRow(row); @@ -3275,36 +3252,35 @@ public class Hbase { prot.writeMessageEnd(); } - public void getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public void getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); (new Client(prot)).recv_deleteAllRow(); } } - public void deleteAllRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void deleteAllRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp, AsyncMethodCallback resultHandler) throws TException { checkReady(); deleteAllRowTs_call method_call = new deleteAllRowTs_call(tableName, row, timestamp, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class deleteAllRowTs_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class deleteAllRowTs_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer row; private long timestamp; - public deleteAllRowTs_call(ByteBuffer tableName, ByteBuffer row, long timestamp, 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 { + public deleteAllRowTs_call(ByteBuffer tableName, ByteBuffer row, long timestamp, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.row = row; this.timestamp = timestamp; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAllRowTs", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.CALL, 0)); deleteAllRowTs_args args = new deleteAllRowTs_args(); args.setTableName(tableName); args.setRow(row); @@ -3313,34 +3289,33 @@ public class Hbase { prot.writeMessageEnd(); } - public void getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public void getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); (new Client(prot)).recv_deleteAllRowTs(); } } - public void scannerOpenWithScan(ByteBuffer tableName, TScan scan, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void scannerOpenWithScan(ByteBuffer tableName, TScan scan, AsyncMethodCallback resultHandler) throws TException { checkReady(); scannerOpenWithScan_call method_call = new scannerOpenWithScan_call(tableName, scan, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class scannerOpenWithScan_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class scannerOpenWithScan_call extends TAsyncMethodCall { private ByteBuffer tableName; private TScan scan; - public scannerOpenWithScan_call(ByteBuffer tableName, TScan scan, 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 { + public scannerOpenWithScan_call(ByteBuffer tableName, TScan scan, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.scan = scan; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithScan", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("scannerOpenWithScan", TMessageType.CALL, 0)); scannerOpenWithScan_args args = new scannerOpenWithScan_args(); args.setTableName(tableName); args.setScan(scan); @@ -3348,36 +3323,35 @@ public class Hbase { prot.writeMessageEnd(); } - public int getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public int getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_scannerOpenWithScan(); } } - public void scannerOpen(ByteBuffer tableName, ByteBuffer startRow, List columns, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void scannerOpen(ByteBuffer tableName, ByteBuffer startRow, List columns, AsyncMethodCallback resultHandler) throws TException { checkReady(); scannerOpen_call method_call = new scannerOpen_call(tableName, startRow, columns, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class scannerOpen_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class scannerOpen_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer startRow; private List columns; - public scannerOpen_call(ByteBuffer tableName, ByteBuffer startRow, List columns, 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 { + public scannerOpen_call(ByteBuffer tableName, ByteBuffer startRow, List columns, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.startRow = startRow; this.columns = columns; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpen", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("scannerOpen", TMessageType.CALL, 0)); scannerOpen_args args = new scannerOpen_args(); args.setTableName(tableName); args.setStartRow(startRow); @@ -3386,29 +3360,28 @@ public class Hbase { prot.writeMessageEnd(); } - public int getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public int getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_scannerOpen(); } } - public void scannerOpenWithStop(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void scannerOpenWithStop(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns, AsyncMethodCallback resultHandler) throws TException { checkReady(); scannerOpenWithStop_call method_call = new scannerOpenWithStop_call(tableName, startRow, stopRow, columns, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class scannerOpenWithStop_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class scannerOpenWithStop_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer startRow; private ByteBuffer stopRow; private List columns; - public scannerOpenWithStop_call(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns, 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 { + public scannerOpenWithStop_call(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.startRow = startRow; @@ -3416,8 +3389,8 @@ public class Hbase { this.columns = columns; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithStop", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.CALL, 0)); scannerOpenWithStop_args args = new scannerOpenWithStop_args(); args.setTableName(tableName); args.setStartRow(startRow); @@ -3427,36 +3400,35 @@ public class Hbase { prot.writeMessageEnd(); } - public int getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public int getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_scannerOpenWithStop(); } } - public void scannerOpenWithPrefix(ByteBuffer tableName, ByteBuffer startAndPrefix, List columns, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void scannerOpenWithPrefix(ByteBuffer tableName, ByteBuffer startAndPrefix, List columns, AsyncMethodCallback resultHandler) throws TException { checkReady(); scannerOpenWithPrefix_call method_call = new scannerOpenWithPrefix_call(tableName, startAndPrefix, columns, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class scannerOpenWithPrefix_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class scannerOpenWithPrefix_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer startAndPrefix; private List columns; - public scannerOpenWithPrefix_call(ByteBuffer tableName, ByteBuffer startAndPrefix, List columns, 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 { + public scannerOpenWithPrefix_call(ByteBuffer tableName, ByteBuffer startAndPrefix, List columns, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.startAndPrefix = startAndPrefix; this.columns = columns; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithPrefix", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.CALL, 0)); scannerOpenWithPrefix_args args = new scannerOpenWithPrefix_args(); args.setTableName(tableName); args.setStartAndPrefix(startAndPrefix); @@ -3465,29 +3437,28 @@ public class Hbase { prot.writeMessageEnd(); } - public int getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public int getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_scannerOpenWithPrefix(); } } - public void scannerOpenTs(ByteBuffer tableName, ByteBuffer startRow, List columns, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void scannerOpenTs(ByteBuffer tableName, ByteBuffer startRow, List columns, long timestamp, AsyncMethodCallback resultHandler) throws TException { checkReady(); scannerOpenTs_call method_call = new scannerOpenTs_call(tableName, startRow, columns, timestamp, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class scannerOpenTs_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class scannerOpenTs_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer startRow; private List columns; private long timestamp; - public scannerOpenTs_call(ByteBuffer tableName, ByteBuffer startRow, List columns, long timestamp, 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 { + public scannerOpenTs_call(ByteBuffer tableName, ByteBuffer startRow, List columns, long timestamp, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.startRow = startRow; @@ -3495,8 +3466,8 @@ public class Hbase { this.timestamp = timestamp; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenTs", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.CALL, 0)); scannerOpenTs_args args = new scannerOpenTs_args(); args.setTableName(tableName); args.setStartRow(startRow); @@ -3506,30 +3477,29 @@ public class Hbase { prot.writeMessageEnd(); } - public int getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public int getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_scannerOpenTs(); } } - public void scannerOpenWithStopTs(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void scannerOpenWithStopTs(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns, long timestamp, AsyncMethodCallback resultHandler) throws TException { checkReady(); scannerOpenWithStopTs_call method_call = new scannerOpenWithStopTs_call(tableName, startRow, stopRow, columns, timestamp, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class scannerOpenWithStopTs_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class scannerOpenWithStopTs_call extends TAsyncMethodCall { private ByteBuffer tableName; private ByteBuffer startRow; private ByteBuffer stopRow; private List columns; private long timestamp; - public scannerOpenWithStopTs_call(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns, long timestamp, 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 { + public scannerOpenWithStopTs_call(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List columns, long timestamp, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.tableName = tableName; this.startRow = startRow; @@ -3538,8 +3508,8 @@ public class Hbase { this.timestamp = timestamp; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithStopTs", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.CALL, 0)); scannerOpenWithStopTs_args args = new scannerOpenWithStopTs_args(); args.setTableName(tableName); args.setStartRow(startRow); @@ -3550,66 +3520,64 @@ public class Hbase { prot.writeMessageEnd(); } - public int getResult() throws IOError, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public int getResult() throws IOError, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_scannerOpenWithStopTs(); } } - public void scannerGet(int id, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void scannerGet(int id, AsyncMethodCallback resultHandler) throws TException { checkReady(); scannerGet_call method_call = new scannerGet_call(id, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class scannerGet_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class scannerGet_call extends TAsyncMethodCall { private int id; - public scannerGet_call(int id, 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 { + public scannerGet_call(int id, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.id = id; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerGet", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("scannerGet", TMessageType.CALL, 0)); scannerGet_args args = new scannerGet_args(); args.setId(id); args.write(prot); prot.writeMessageEnd(); } - public List getResult() throws IOError, IllegalArgument, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public List getResult() throws IOError, IllegalArgument, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_scannerGet(); } } - public void scannerGetList(int id, int nbRows, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void scannerGetList(int id, int nbRows, AsyncMethodCallback resultHandler) throws TException { checkReady(); scannerGetList_call method_call = new scannerGetList_call(id, nbRows, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class scannerGetList_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class scannerGetList_call extends TAsyncMethodCall { private int id; private int nbRows; - public scannerGetList_call(int id, int nbRows, 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 { + public scannerGetList_call(int id, int nbRows, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.id = id; this.nbRows = nbRows; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerGetList", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("scannerGetList", TMessageType.CALL, 0)); scannerGetList_args args = new scannerGetList_args(); args.setId(id); args.setNbRows(nbRows); @@ -3617,51 +3585,50 @@ public class Hbase { prot.writeMessageEnd(); } - public List getResult() throws IOError, IllegalArgument, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public List getResult() throws IOError, IllegalArgument, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); return (new Client(prot)).recv_scannerGetList(); } } - public void scannerClose(int id, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void scannerClose(int id, AsyncMethodCallback resultHandler) throws TException { checkReady(); scannerClose_call method_call = new scannerClose_call(id, resultHandler, this, protocolFactory, transport); - this.currentMethod = method_call; manager.call(method_call); } - public static class scannerClose_call extends org.apache.thrift.async.TAsyncMethodCall { + public static class scannerClose_call extends TAsyncMethodCall { private int id; - public scannerClose_call(int id, 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 { + public scannerClose_call(int id, AsyncMethodCallback resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException { super(client, protocolFactory, transport, resultHandler, false); this.id = id; } - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerClose", org.apache.thrift.protocol.TMessageType.CALL, 0)); + public void write_args(TProtocol prot) throws TException { + prot.writeMessageBegin(new TMessage("scannerClose", TMessageType.CALL, 0)); scannerClose_args args = new scannerClose_args(); args.setId(id); args.write(prot); prot.writeMessageEnd(); } - public void getResult() throws IOError, IllegalArgument, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + public void getResult() throws IOError, IllegalArgument, TException { + if (getState() != State.RESPONSE_READ) { throw new IllegalStateException("Method call not finished!"); } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array()); + TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); (new Client(prot)).recv_scannerClose(); } } } - public static class Processor implements org.apache.thrift.TProcessor { + public static class Processor implements TProcessor { private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName()); public Processor(Iface iface) { @@ -3708,21 +3675,21 @@ public class Hbase { } protected static interface ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException; + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException; } private Iface iface_; protected final HashMap processMap_ = new HashMap(); - public boolean process(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public boolean process(TProtocol iprot, TProtocol oprot) throws TException { - org.apache.thrift.protocol.TMessage msg = iprot.readMessageBegin(); + TMessage msg = iprot.readMessageBegin(); ProcessFunction fn = processMap_.get(msg.name); if (fn == null) { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, org.apache.thrift.protocol.TType.STRUCT); + TProtocolUtil.skip(iprot, TType.STRUCT); iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.UNKNOWN_METHOD, "Invalid method name: '"+msg.name+"'"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage(msg.name, org.apache.thrift.protocol.TMessageType.EXCEPTION, msg.seqid)); + TApplicationException x = new TApplicationException(TApplicationException.UNKNOWN_METHOD, "Invalid method name: '"+msg.name+"'"); + oprot.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -3733,15 +3700,15 @@ public class Hbase { } private class enableTable implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { enableTable_args args = new enableTable_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("enableTable", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("enableTable", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -3755,14 +3722,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing enableTable", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing enableTable"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("enableTable", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing enableTable"); + oprot.writeMessageBegin(new TMessage("enableTable", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("enableTable", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("enableTable", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -3771,15 +3738,15 @@ public class Hbase { } private class disableTable implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { disableTable_args args = new disableTable_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("disableTable", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("disableTable", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -3793,14 +3760,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing disableTable", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing disableTable"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("disableTable", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing disableTable"); + oprot.writeMessageBegin(new TMessage("disableTable", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("disableTable", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("disableTable", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -3809,15 +3776,15 @@ public class Hbase { } private class isTableEnabled implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { isTableEnabled_args args = new isTableEnabled_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("isTableEnabled", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -3832,14 +3799,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing isTableEnabled", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing isTableEnabled"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("isTableEnabled", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing isTableEnabled"); + oprot.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("isTableEnabled", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -3848,15 +3815,15 @@ public class Hbase { } private class compact implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { compact_args args = new compact_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("compact", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("compact", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -3870,14 +3837,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing compact", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing compact"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("compact", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing compact"); + oprot.writeMessageBegin(new TMessage("compact", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("compact", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("compact", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -3886,15 +3853,15 @@ public class Hbase { } private class majorCompact implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { majorCompact_args args = new majorCompact_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("majorCompact", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("majorCompact", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -3908,14 +3875,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing majorCompact", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing majorCompact"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("majorCompact", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing majorCompact"); + oprot.writeMessageBegin(new TMessage("majorCompact", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("majorCompact", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("majorCompact", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -3924,15 +3891,15 @@ public class Hbase { } private class getTableNames implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { getTableNames_args args = new getTableNames_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTableNames", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("getTableNames", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -3946,14 +3913,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing getTableNames", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing getTableNames"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTableNames", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getTableNames"); + oprot.writeMessageBegin(new TMessage("getTableNames", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTableNames", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("getTableNames", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -3962,15 +3929,15 @@ public class Hbase { } private class getColumnDescriptors implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { getColumnDescriptors_args args = new getColumnDescriptors_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getColumnDescriptors", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -3984,14 +3951,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing getColumnDescriptors", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing getColumnDescriptors"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getColumnDescriptors", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getColumnDescriptors"); + oprot.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getColumnDescriptors", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4000,15 +3967,15 @@ public class Hbase { } private class getTableRegions implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { getTableRegions_args args = new getTableRegions_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTableRegions", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("getTableRegions", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4022,14 +3989,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing getTableRegions", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing getTableRegions"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTableRegions", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getTableRegions"); + oprot.writeMessageBegin(new TMessage("getTableRegions", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTableRegions", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("getTableRegions", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4038,15 +4005,15 @@ public class Hbase { } private class createTable implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { createTable_args args = new createTable_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("createTable", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("createTable", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4064,14 +4031,14 @@ public class Hbase { result.exist = exist; } catch (Throwable th) { LOGGER.error("Internal error processing createTable", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing createTable"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("createTable", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing createTable"); + oprot.writeMessageBegin(new TMessage("createTable", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("createTable", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("createTable", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4080,15 +4047,15 @@ public class Hbase { } private class deleteTable implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { deleteTable_args args = new deleteTable_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteTable", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("deleteTable", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4102,14 +4069,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing deleteTable", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing deleteTable"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteTable", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteTable"); + oprot.writeMessageBegin(new TMessage("deleteTable", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteTable", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("deleteTable", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4118,15 +4085,15 @@ public class Hbase { } private class get implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { get_args args = new get_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("get", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("get", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4140,14 +4107,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing get", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing get"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("get", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing get"); + oprot.writeMessageBegin(new TMessage("get", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("get", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("get", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4156,15 +4123,15 @@ public class Hbase { } private class getVer implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { getVer_args args = new getVer_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getVer", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("getVer", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4178,14 +4145,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing getVer", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing getVer"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getVer", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getVer"); + oprot.writeMessageBegin(new TMessage("getVer", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getVer", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("getVer", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4194,15 +4161,15 @@ public class Hbase { } private class getVerTs implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { getVerTs_args args = new getVerTs_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getVerTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("getVerTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4216,14 +4183,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing getVerTs", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing getVerTs"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getVerTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getVerTs"); + oprot.writeMessageBegin(new TMessage("getVerTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getVerTs", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("getVerTs", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4232,15 +4199,15 @@ public class Hbase { } private class getRow implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { getRow_args args = new getRow_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRow", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("getRow", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4254,14 +4221,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing getRow", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing getRow"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRow", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRow"); + oprot.writeMessageBegin(new TMessage("getRow", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRow", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("getRow", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4270,15 +4237,15 @@ public class Hbase { } private class getRowWithColumns implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { getRowWithColumns_args args = new getRowWithColumns_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumns", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4292,14 +4259,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing getRowWithColumns", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing getRowWithColumns"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumns", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowWithColumns"); + oprot.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumns", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4308,15 +4275,15 @@ public class Hbase { } private class getRowTs implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { getRowTs_args args = new getRowTs_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("getRowTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4330,14 +4297,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing getRowTs", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing getRowTs"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowTs"); + oprot.writeMessageBegin(new TMessage("getRowTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowTs", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("getRowTs", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4346,15 +4313,15 @@ public class Hbase { } private class getRowWithColumnsTs implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { getRowWithColumnsTs_args args = new getRowWithColumnsTs_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumnsTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4368,14 +4335,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing getRowWithColumnsTs", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing getRowWithColumnsTs"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumnsTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowWithColumnsTs"); + oprot.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumnsTs", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4384,15 +4351,15 @@ public class Hbase { } private class getRows implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { getRows_args args = new getRows_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRows", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("getRows", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4406,14 +4373,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing getRows", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing getRows"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRows", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRows"); + oprot.writeMessageBegin(new TMessage("getRows", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRows", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("getRows", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4422,15 +4389,15 @@ public class Hbase { } private class getRowsWithColumns implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { getRowsWithColumns_args args = new getRowsWithColumns_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowsWithColumns", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("getRowsWithColumns", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4444,14 +4411,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing getRowsWithColumns", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing getRowsWithColumns"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowsWithColumns", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowsWithColumns"); + oprot.writeMessageBegin(new TMessage("getRowsWithColumns", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowsWithColumns", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("getRowsWithColumns", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4460,15 +4427,15 @@ public class Hbase { } private class getRowsTs implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { getRowsTs_args args = new getRowsTs_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowsTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("getRowsTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4482,14 +4449,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing getRowsTs", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing getRowsTs"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowsTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowsTs"); + oprot.writeMessageBegin(new TMessage("getRowsTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowsTs", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("getRowsTs", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4498,15 +4465,15 @@ public class Hbase { } private class getRowsWithColumnsTs implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { getRowsWithColumnsTs_args args = new getRowsWithColumnsTs_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowsWithColumnsTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("getRowsWithColumnsTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4520,14 +4487,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing getRowsWithColumnsTs", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing getRowsWithColumnsTs"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowsWithColumnsTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowsWithColumnsTs"); + oprot.writeMessageBegin(new TMessage("getRowsWithColumnsTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowsWithColumnsTs", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("getRowsWithColumnsTs", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4536,15 +4503,15 @@ public class Hbase { } private class mutateRow implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { mutateRow_args args = new mutateRow_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRow", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("mutateRow", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4560,14 +4527,14 @@ public class Hbase { result.ia = ia; } catch (Throwable th) { LOGGER.error("Internal error processing mutateRow", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRow"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRow", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRow"); + oprot.writeMessageBegin(new TMessage("mutateRow", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRow", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("mutateRow", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4576,15 +4543,15 @@ public class Hbase { } private class mutateRowTs implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { mutateRowTs_args args = new mutateRowTs_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRowTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4600,14 +4567,14 @@ public class Hbase { result.ia = ia; } catch (Throwable th) { LOGGER.error("Internal error processing mutateRowTs", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRowTs"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRowTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRowTs"); + oprot.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRowTs", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4616,15 +4583,15 @@ public class Hbase { } private class mutateRows implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { mutateRows_args args = new mutateRows_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRows", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("mutateRows", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4640,14 +4607,14 @@ public class Hbase { result.ia = ia; } catch (Throwable th) { LOGGER.error("Internal error processing mutateRows", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRows"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRows", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRows"); + oprot.writeMessageBegin(new TMessage("mutateRows", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRows", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("mutateRows", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4656,15 +4623,15 @@ public class Hbase { } private class mutateRowsTs implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { mutateRowsTs_args args = new mutateRowsTs_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRowsTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4680,14 +4647,14 @@ public class Hbase { result.ia = ia; } catch (Throwable th) { LOGGER.error("Internal error processing mutateRowsTs", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRowsTs"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRowsTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRowsTs"); + oprot.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRowsTs", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4696,15 +4663,15 @@ public class Hbase { } private class atomicIncrement implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { atomicIncrement_args args = new atomicIncrement_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("atomicIncrement", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4721,14 +4688,14 @@ public class Hbase { result.ia = ia; } catch (Throwable th) { LOGGER.error("Internal error processing atomicIncrement", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing atomicIncrement"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("atomicIncrement", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing atomicIncrement"); + oprot.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("atomicIncrement", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4737,15 +4704,15 @@ public class Hbase { } private class deleteAll implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { deleteAll_args args = new deleteAll_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAll", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("deleteAll", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4759,14 +4726,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing deleteAll", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAll"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAll", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAll"); + oprot.writeMessageBegin(new TMessage("deleteAll", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAll", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("deleteAll", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4775,15 +4742,15 @@ public class Hbase { } private class deleteAllTs implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { deleteAllTs_args args = new deleteAllTs_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAllTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4797,14 +4764,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing deleteAllTs", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAllTs"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAllTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAllTs"); + oprot.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAllTs", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4813,15 +4780,15 @@ public class Hbase { } private class deleteAllRow implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { deleteAllRow_args args = new deleteAllRow_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAllRow", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4835,14 +4802,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing deleteAllRow", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAllRow"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAllRow", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAllRow"); + oprot.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAllRow", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4851,15 +4818,15 @@ public class Hbase { } private class deleteAllRowTs implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { deleteAllRowTs_args args = new deleteAllRowTs_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAllRowTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4873,14 +4840,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing deleteAllRowTs", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAllRowTs"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAllRowTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAllRowTs"); + oprot.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteAllRowTs", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4889,15 +4856,15 @@ public class Hbase { } private class scannerOpenWithScan implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { scannerOpenWithScan_args args = new scannerOpenWithScan_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithScan", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("scannerOpenWithScan", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4912,14 +4879,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing scannerOpenWithScan", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithScan"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithScan", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithScan"); + oprot.writeMessageBegin(new TMessage("scannerOpenWithScan", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithScan", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("scannerOpenWithScan", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4928,15 +4895,15 @@ public class Hbase { } private class scannerOpen implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { scannerOpen_args args = new scannerOpen_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpen", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("scannerOpen", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4951,14 +4918,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing scannerOpen", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpen"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpen", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpen"); + oprot.writeMessageBegin(new TMessage("scannerOpen", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpen", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("scannerOpen", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4967,15 +4934,15 @@ public class Hbase { } private class scannerOpenWithStop implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { scannerOpenWithStop_args args = new scannerOpenWithStop_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithStop", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -4990,14 +4957,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing scannerOpenWithStop", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithStop"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithStop", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithStop"); + oprot.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithStop", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -5006,15 +4973,15 @@ public class Hbase { } private class scannerOpenWithPrefix implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { scannerOpenWithPrefix_args args = new scannerOpenWithPrefix_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithPrefix", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -5029,14 +4996,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing scannerOpenWithPrefix", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithPrefix"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithPrefix", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithPrefix"); + oprot.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithPrefix", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -5045,15 +5012,15 @@ public class Hbase { } private class scannerOpenTs implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { scannerOpenTs_args args = new scannerOpenTs_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -5068,14 +5035,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing scannerOpenTs", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenTs"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenTs"); + oprot.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenTs", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -5084,15 +5051,15 @@ public class Hbase { } private class scannerOpenWithStopTs implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { scannerOpenWithStopTs_args args = new scannerOpenWithStopTs_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithStopTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -5107,14 +5074,14 @@ public class Hbase { result.io = io; } catch (Throwable th) { LOGGER.error("Internal error processing scannerOpenWithStopTs", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithStopTs"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithStopTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithStopTs"); + oprot.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerOpenWithStopTs", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -5123,15 +5090,15 @@ public class Hbase { } private class scannerGet implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { scannerGet_args args = new scannerGet_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerGet", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("scannerGet", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -5147,14 +5114,14 @@ public class Hbase { result.ia = ia; } catch (Throwable th) { LOGGER.error("Internal error processing scannerGet", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing scannerGet"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerGet", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerGet"); + oprot.writeMessageBegin(new TMessage("scannerGet", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerGet", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("scannerGet", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -5163,15 +5130,15 @@ public class Hbase { } private class scannerGetList implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { scannerGetList_args args = new scannerGetList_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerGetList", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("scannerGetList", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -5187,14 +5154,14 @@ public class Hbase { result.ia = ia; } catch (Throwable th) { LOGGER.error("Internal error processing scannerGetList", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing scannerGetList"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerGetList", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerGetList"); + oprot.writeMessageBegin(new TMessage("scannerGetList", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerGetList", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("scannerGetList", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -5203,15 +5170,15 @@ public class Hbase { } private class scannerClose implements ProcessFunction { - public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException { scannerClose_args args = new scannerClose_args(); try { args.read(iprot); - } catch (org.apache.thrift.protocol.TProtocolException e) { + } catch (TProtocolException e) { iprot.readMessageEnd(); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerClose", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new TMessage("scannerClose", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -5227,14 +5194,14 @@ public class Hbase { result.ia = ia; } catch (Throwable th) { LOGGER.error("Internal error processing scannerClose", th); - org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing scannerClose"); - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerClose", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerClose"); + oprot.writeMessageBegin(new TMessage("scannerClose", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } - oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("scannerClose", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + oprot.writeMessageBegin(new TMessage("scannerClose", TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); @@ -5244,10 +5211,10 @@ public class Hbase { } - public static class enableTable_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("enableTable_args"); + public static class enableTable_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("enableTable_args"); - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); /** * name of the table @@ -5255,7 +5222,7 @@ public class Hbase { public ByteBuffer tableName; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of the table */ @@ -5317,13 +5284,13 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Bytes"))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Bytes"))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(enableTable_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(enableTable_args.class, metaDataMap); } public enableTable_args() { @@ -5358,11 +5325,11 @@ public class Hbase { * name of the table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -5370,7 +5337,7 @@ public class Hbase { * name of the table */ public enableTable_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -5383,7 +5350,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -5416,7 +5383,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -5472,7 +5439,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -5484,25 +5451,25 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -5512,7 +5479,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -5541,37 +5508,21 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class enableTable_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("enableTable_result"); - } - - public static class enableTable_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("enableTable_result"); - - 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 TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { IO((short)1, "io"); private static final Map byName = new HashMap(); @@ -5630,13 +5581,13 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(enableTable_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(enableTable_result.class, metaDataMap); } public enableTable_result() { @@ -5680,7 +5631,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -5713,7 +5664,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -5769,7 +5720,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -5781,26 +5732,26 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -5810,7 +5761,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetIo()) { @@ -5838,32 +5789,16 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class disableTable_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("disableTable_args"); - } - - public static class disableTable_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("disableTable_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); /** * name of the table @@ -5871,7 +5806,7 @@ public class Hbase { public ByteBuffer tableName; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of the table */ @@ -5933,13 +5868,13 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Bytes"))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Bytes"))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(disableTable_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(disableTable_args.class, metaDataMap); } public disableTable_args() { @@ -5974,11 +5909,11 @@ public class Hbase { * name of the table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -5986,7 +5921,7 @@ public class Hbase { * name of the table */ public disableTable_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -5999,7 +5934,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -6032,7 +5967,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -6088,7 +6023,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -6100,25 +6035,25 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -6128,7 +6063,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -6157,37 +6092,21 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class disableTable_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("disableTable_result"); - } - - public static class disableTable_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("disableTable_result"); - - 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 TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { IO((short)1, "io"); private static final Map byName = new HashMap(); @@ -6246,13 +6165,13 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(disableTable_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(disableTable_result.class, metaDataMap); } public disableTable_result() { @@ -6296,7 +6215,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -6329,7 +6248,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -6385,7 +6304,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -6397,26 +6316,26 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -6426,7 +6345,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetIo()) { @@ -6454,32 +6373,16 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class isTableEnabled_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("isTableEnabled_args"); - } - - public static class isTableEnabled_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isTableEnabled_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); /** * name of the table to check @@ -6487,7 +6390,7 @@ public class Hbase { public ByteBuffer tableName; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of the table to check */ @@ -6549,13 +6452,13 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Bytes"))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Bytes"))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTableEnabled_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(isTableEnabled_args.class, metaDataMap); } public isTableEnabled_args() { @@ -6590,11 +6493,11 @@ public class Hbase { * name of the table to check */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -6602,7 +6505,7 @@ public class Hbase { * name of the table to check */ public isTableEnabled_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -6615,7 +6518,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -6648,7 +6551,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -6704,7 +6607,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -6716,25 +6619,25 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -6744,7 +6647,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -6773,39 +6676,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class isTableEnabled_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("isTableEnabled_result"); - } - - public static class isTableEnabled_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isTableEnabled_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.BOOL, (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 TField SUCCESS_FIELD_DESC = new TField("success", TType.BOOL, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public boolean success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -6869,15 +6756,15 @@ public class Hbase { private static final int __SUCCESS_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.BOOL))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTableEnabled_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(isTableEnabled_result.class, metaDataMap); } public isTableEnabled_result() { @@ -6930,7 +6817,7 @@ public class Hbase { __isset_bit_vector.clear(__SUCCESS_ISSET_ID); } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return __isset_bit_vector.get(__SUCCESS_ISSET_ID); } @@ -6952,7 +6839,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -6996,7 +6883,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -7063,7 +6950,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -7073,7 +6960,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -7085,34 +6972,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.BOOL) { + if (field.type == TType.BOOL) { this.success = iprot.readBool(); setSuccessIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -7122,7 +7009,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { @@ -7158,37 +7045,21 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class compact_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("compact_args"); - } - - public static class compact_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("compact_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_OR_REGION_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableNameOrRegionName", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final TField TABLE_NAME_OR_REGION_NAME_FIELD_DESC = new TField("tableNameOrRegionName", TType.STRING, (short)1); public ByteBuffer tableNameOrRegionName; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { TABLE_NAME_OR_REGION_NAME((short)1, "tableNameOrRegionName"); private static final Map byName = new HashMap(); @@ -7247,13 +7118,13 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME_OR_REGION_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableNameOrRegionName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Bytes"))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME_OR_REGION_NAME, new FieldMetaData("tableNameOrRegionName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Bytes"))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(compact_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(compact_args.class, metaDataMap); } public compact_args() { @@ -7285,16 +7156,16 @@ public class Hbase { } public byte[] getTableNameOrRegionName() { - setTableNameOrRegionName(org.apache.thrift.TBaseHelper.rightSize(tableNameOrRegionName)); - return tableNameOrRegionName == null ? null : tableNameOrRegionName.array(); + setTableNameOrRegionName(TBaseHelper.rightSize(tableNameOrRegionName)); + return tableNameOrRegionName.array(); } - public ByteBuffer bufferForTableNameOrRegionName() { + public ByteBuffer BufferForTableNameOrRegionName() { return tableNameOrRegionName; } public compact_args setTableNameOrRegionName(byte[] tableNameOrRegionName) { - setTableNameOrRegionName(tableNameOrRegionName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableNameOrRegionName)); + setTableNameOrRegionName(ByteBuffer.wrap(tableNameOrRegionName)); return this; } @@ -7307,7 +7178,7 @@ public class Hbase { this.tableNameOrRegionName = null; } - /** Returns true if field tableNameOrRegionName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableNameOrRegionName is set (has been asigned a value) and false otherwise */ public boolean isSetTableNameOrRegionName() { return this.tableNameOrRegionName != null; } @@ -7340,7 +7211,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -7396,7 +7267,7 @@ public class Hbase { return lastComparison; } if (isSetTableNameOrRegionName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableNameOrRegionName, typedOther.tableNameOrRegionName); + lastComparison = TBaseHelper.compareTo(this.tableNameOrRegionName, typedOther.tableNameOrRegionName); if (lastComparison != 0) { return lastComparison; } @@ -7408,25 +7279,25 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME_OR_REGION_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableNameOrRegionName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -7436,7 +7307,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -7465,37 +7336,21 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class compact_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("compact_result"); - } - - public static class compact_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("compact_result"); - - 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 TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { IO((short)1, "io"); private static final Map byName = new HashMap(); @@ -7554,13 +7409,13 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(compact_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(compact_result.class, metaDataMap); } public compact_result() { @@ -7604,7 +7459,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -7637,7 +7492,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -7693,7 +7548,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -7705,26 +7560,26 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -7734,7 +7589,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetIo()) { @@ -7762,37 +7617,21 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class majorCompact_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("majorCompact_args"); - } - - public static class majorCompact_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("majorCompact_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_OR_REGION_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableNameOrRegionName", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final TField TABLE_NAME_OR_REGION_NAME_FIELD_DESC = new TField("tableNameOrRegionName", TType.STRING, (short)1); public ByteBuffer tableNameOrRegionName; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { TABLE_NAME_OR_REGION_NAME((short)1, "tableNameOrRegionName"); private static final Map byName = new HashMap(); @@ -7851,13 +7690,13 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME_OR_REGION_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableNameOrRegionName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Bytes"))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME_OR_REGION_NAME, new FieldMetaData("tableNameOrRegionName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Bytes"))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(majorCompact_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(majorCompact_args.class, metaDataMap); } public majorCompact_args() { @@ -7889,16 +7728,16 @@ public class Hbase { } public byte[] getTableNameOrRegionName() { - setTableNameOrRegionName(org.apache.thrift.TBaseHelper.rightSize(tableNameOrRegionName)); - return tableNameOrRegionName == null ? null : tableNameOrRegionName.array(); + setTableNameOrRegionName(TBaseHelper.rightSize(tableNameOrRegionName)); + return tableNameOrRegionName.array(); } - public ByteBuffer bufferForTableNameOrRegionName() { + public ByteBuffer BufferForTableNameOrRegionName() { return tableNameOrRegionName; } public majorCompact_args setTableNameOrRegionName(byte[] tableNameOrRegionName) { - setTableNameOrRegionName(tableNameOrRegionName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableNameOrRegionName)); + setTableNameOrRegionName(ByteBuffer.wrap(tableNameOrRegionName)); return this; } @@ -7911,7 +7750,7 @@ public class Hbase { this.tableNameOrRegionName = null; } - /** Returns true if field tableNameOrRegionName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableNameOrRegionName is set (has been asigned a value) and false otherwise */ public boolean isSetTableNameOrRegionName() { return this.tableNameOrRegionName != null; } @@ -7944,7 +7783,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -8000,7 +7839,7 @@ public class Hbase { return lastComparison; } if (isSetTableNameOrRegionName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableNameOrRegionName, typedOther.tableNameOrRegionName); + lastComparison = TBaseHelper.compareTo(this.tableNameOrRegionName, typedOther.tableNameOrRegionName); if (lastComparison != 0) { return lastComparison; } @@ -8012,25 +7851,25 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME_OR_REGION_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableNameOrRegionName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -8040,7 +7879,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -8069,37 +7908,21 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class majorCompact_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("majorCompact_result"); - } - - public static class majorCompact_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("majorCompact_result"); - - 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 TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { IO((short)1, "io"); private static final Map byName = new HashMap(); @@ -8158,13 +7981,13 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(majorCompact_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(majorCompact_result.class, metaDataMap); } public majorCompact_result() { @@ -8208,7 +8031,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -8241,7 +8064,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -8297,7 +8120,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -8309,26 +8132,26 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -8338,7 +8161,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetIo()) { @@ -8366,35 +8189,19 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } - - } - - public static class getTableNames_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableNames_args"); + public static class getTableNames_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getTableNames_args"); /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { ; private static final Map byName = new HashMap(); @@ -8448,11 +8255,11 @@ public class Hbase { return _fieldName; } } - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableNames_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getTableNames_args.class, metaDataMap); } public getTableNames_args() { @@ -8483,7 +8290,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -8530,18 +8337,18 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -8551,7 +8358,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -8568,39 +8375,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getTableNames_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getTableNames_result"); - } - - public static class getTableNames_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableNames_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); - private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public List success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -8662,16 +8453,16 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new FieldValueMetaData(TType.STRING , "Text")))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableNames_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getTableNames_result.class, metaDataMap); } public getTableNames_result() { @@ -8740,7 +8531,7 @@ public class Hbase { this.success = null; } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return this.success != null; } @@ -8764,7 +8555,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -8808,7 +8599,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -8875,7 +8666,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -8885,7 +8676,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -8897,20 +8688,20 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list13 = iprot.readListBegin(); + TList _list13 = iprot.readListBegin(); this.success = new ArrayList(_list13.size); for (int _i14 = 0; _i14 < _list13.size; ++_i14) { @@ -8921,19 +8712,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -8943,13 +8734,13 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size())); + oprot.writeListBegin(new TList(TType.STRING, this.success.size())); for (ByteBuffer _iter16 : this.success) { oprot.writeBinary(_iter16); @@ -8990,32 +8781,16 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getColumnDescriptors_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getColumnDescriptors_args"); - } - - public static class getColumnDescriptors_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getColumnDescriptors_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); /** * table name @@ -9023,7 +8798,7 @@ public class Hbase { public ByteBuffer tableName; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * table name */ @@ -9085,13 +8860,13 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getColumnDescriptors_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getColumnDescriptors_args.class, metaDataMap); } public getColumnDescriptors_args() { @@ -9126,11 +8901,11 @@ public class Hbase { * table name */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -9138,7 +8913,7 @@ public class Hbase { * table name */ public getColumnDescriptors_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -9151,7 +8926,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -9184,7 +8959,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -9240,7 +9015,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -9252,25 +9027,25 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -9280,7 +9055,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -9309,39 +9084,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getColumnDescriptors_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getColumnDescriptors_result"); - } - - public static class getColumnDescriptors_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getColumnDescriptors_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 TField SUCCESS_FIELD_DESC = new TField("success", TType.MAP, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public Map success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -9403,17 +9162,17 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ColumnDescriptor.class)))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new MapMetaData(TType.MAP, + new FieldValueMetaData(TType.STRING , "Text"), + new StructMetaData(TType.STRUCT, ColumnDescriptor.class)))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getColumnDescriptors_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getColumnDescriptors_result.class, metaDataMap); } public getColumnDescriptors_result() { @@ -9486,7 +9245,7 @@ public class Hbase { this.success = null; } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return this.success != null; } @@ -9510,7 +9269,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -9554,7 +9313,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -9621,7 +9380,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -9631,7 +9390,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -9643,20 +9402,20 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.MAP) { + if (field.type == TType.MAP) { { - org.apache.thrift.protocol.TMap _map17 = iprot.readMapBegin(); + TMap _map17 = iprot.readMapBegin(); this.success = new HashMap(2*_map17.size); for (int _i18 = 0; _i18 < _map17.size; ++_i18) { @@ -9670,19 +9429,19 @@ public class Hbase { iprot.readMapEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -9692,13 +9451,13 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { 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, this.success.size())); + oprot.writeMapBegin(new TMap(TType.STRING, TType.STRUCT, this.success.size())); for (Map.Entry _iter21 : this.success.entrySet()) { oprot.writeBinary(_iter21.getKey()); @@ -9740,32 +9499,16 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getTableRegions_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getTableRegions_args"); - } - - public static class getTableRegions_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableRegions_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); /** * table name @@ -9773,7 +9516,7 @@ public class Hbase { public ByteBuffer tableName; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * table name */ @@ -9835,13 +9578,13 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableRegions_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getTableRegions_args.class, metaDataMap); } public getTableRegions_args() { @@ -9876,11 +9619,11 @@ public class Hbase { * table name */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -9888,7 +9631,7 @@ public class Hbase { * table name */ public getTableRegions_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -9901,7 +9644,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -9934,7 +9677,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -9990,7 +9733,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -10002,25 +9745,25 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -10030,7 +9773,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -10059,39 +9802,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getTableRegions_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getTableRegions_result"); - } - - public static class getTableRegions_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableRegions_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); - private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public List success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -10153,16 +9880,16 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRegionInfo.class)))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, TRegionInfo.class)))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableRegions_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getTableRegions_result.class, metaDataMap); } public getTableRegions_result() { @@ -10231,7 +9958,7 @@ public class Hbase { this.success = null; } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return this.success != null; } @@ -10255,7 +9982,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -10299,7 +10026,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -10366,7 +10093,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -10376,7 +10103,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -10388,20 +10115,20 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list22 = iprot.readListBegin(); + TList _list22 = iprot.readListBegin(); this.success = new ArrayList(_list22.size); for (int _i23 = 0; _i23 < _list22.size; ++_i23) { @@ -10413,19 +10140,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -10435,13 +10162,13 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.success.size())); for (TRegionInfo _iter25 : this.success) { _iter25.write(oprot); @@ -10482,33 +10209,17 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class createTable_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("createTable_args"); - } - - public static class createTable_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("createTable_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField COLUMN_FAMILIES_FIELD_DESC = new org.apache.thrift.protocol.TField("columnFamilies", org.apache.thrift.protocol.TType.LIST, (short)2); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField COLUMN_FAMILIES_FIELD_DESC = new TField("columnFamilies", TType.LIST, (short)2); /** * name of table to create @@ -10520,7 +10231,7 @@ public class Hbase { public List columnFamilies; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table to create */ @@ -10588,16 +10299,16 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.COLUMN_FAMILIES, new org.apache.thrift.meta_data.FieldMetaData("columnFamilies", 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, ColumnDescriptor.class)))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMN_FAMILIES, new FieldMetaData("columnFamilies", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, ColumnDescriptor.class)))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(createTable_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(createTable_args.class, metaDataMap); } public createTable_args() { @@ -10642,11 +10353,11 @@ public class Hbase { * name of table to create */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -10654,7 +10365,7 @@ public class Hbase { * name of table to create */ public createTable_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -10667,7 +10378,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -10712,7 +10423,7 @@ public class Hbase { this.columnFamilies = null; } - /** Returns true if field columnFamilies is set (has been assigned a value) and false otherwise */ + /** Returns true if field columnFamilies is set (has been asigned a value) and false otherwise */ public boolean isSetColumnFamilies() { return this.columnFamilies != null; } @@ -10756,7 +10467,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -10823,7 +10534,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -10833,7 +10544,7 @@ public class Hbase { return lastComparison; } if (isSetColumnFamilies()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columnFamilies, typedOther.columnFamilies); + lastComparison = TBaseHelper.compareTo(this.columnFamilies, typedOther.columnFamilies); if (lastComparison != 0) { return lastComparison; } @@ -10845,27 +10556,27 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // COLUMN_FAMILIES - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list26 = iprot.readListBegin(); + TList _list26 = iprot.readListBegin(); this.columnFamilies = new ArrayList(_list26.size); for (int _i27 = 0; _i27 < _list26.size; ++_i27) { @@ -10877,11 +10588,11 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -10891,7 +10602,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -10903,7 +10614,7 @@ public class Hbase { if (this.columnFamilies != null) { oprot.writeFieldBegin(COLUMN_FAMILIES_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.columnFamilies.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.columnFamilies.size())); for (ColumnDescriptor _iter29 : this.columnFamilies) { _iter29.write(oprot); @@ -10940,41 +10651,25 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class createTable_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("createTable_result"); - } - - public static class createTable_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("createTable_result"); - - 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.protocol.TField IA_FIELD_DESC = new org.apache.thrift.protocol.TField("ia", org.apache.thrift.protocol.TType.STRUCT, (short)2); - private static final org.apache.thrift.protocol.TField EXIST_FIELD_DESC = new org.apache.thrift.protocol.TField("exist", org.apache.thrift.protocol.TType.STRUCT, (short)3); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); + private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2); + private static final TField EXIST_FIELD_DESC = new TField("exist", TType.STRUCT, (short)3); public IOError io; public IllegalArgument ia; public AlreadyExists exist; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { IO((short)1, "io"), IA((short)2, "ia"), EXIST((short)3, "exist"); @@ -11039,17 +10734,17 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); - tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); - tmpMap.put(_Fields.EXIST, new org.apache.thrift.meta_data.FieldMetaData("exist", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); + tmpMap.put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); + tmpMap.put(_Fields.EXIST, new FieldMetaData("exist", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(createTable_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(createTable_result.class, metaDataMap); } public createTable_result() { @@ -11105,7 +10800,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -11129,7 +10824,7 @@ public class Hbase { this.ia = null; } - /** Returns true if field ia is set (has been assigned a value) and false otherwise */ + /** Returns true if field ia is set (has been asigned a value) and false otherwise */ public boolean isSetIa() { return this.ia != null; } @@ -11153,7 +10848,7 @@ public class Hbase { this.exist = null; } - /** Returns true if field exist is set (has been assigned a value) and false otherwise */ + /** Returns true if field exist is set (has been asigned a value) and false otherwise */ public boolean isSetExist() { return this.exist != null; } @@ -11208,7 +10903,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -11286,7 +10981,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -11296,7 +10991,7 @@ public class Hbase { return lastComparison; } if (isSetIa()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, typedOther.ia); + lastComparison = TBaseHelper.compareTo(this.ia, typedOther.ia); if (lastComparison != 0) { return lastComparison; } @@ -11306,7 +11001,7 @@ public class Hbase { return lastComparison; } if (isSetExist()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.exist, typedOther.exist); + lastComparison = TBaseHelper.compareTo(this.exist, typedOther.exist); if (lastComparison != 0) { return lastComparison; } @@ -11318,42 +11013,42 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // IA - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.ia = new IllegalArgument(); this.ia.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // EXIST - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.exist = new AlreadyExists(); this.exist.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -11363,7 +11058,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetIo()) { @@ -11415,32 +11110,16 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class deleteTable_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("deleteTable_args"); - } - - public static class deleteTable_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteTable_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); /** * name of table to delete @@ -11448,7 +11127,7 @@ public class Hbase { public ByteBuffer tableName; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table to delete */ @@ -11510,13 +11189,13 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteTable_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(deleteTable_args.class, metaDataMap); } public deleteTable_args() { @@ -11551,11 +11230,11 @@ public class Hbase { * name of table to delete */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -11563,7 +11242,7 @@ public class Hbase { * name of table to delete */ public deleteTable_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -11576,7 +11255,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -11609,7 +11288,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -11665,7 +11344,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -11677,25 +11356,25 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -11705,7 +11384,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -11734,37 +11413,21 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class deleteTable_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("deleteTable_result"); - } - - public static class deleteTable_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteTable_result"); - - 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 TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { IO((short)1, "io"); private static final Map byName = new HashMap(); @@ -11823,13 +11486,13 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteTable_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(deleteTable_result.class, metaDataMap); } public deleteTable_result() { @@ -11873,7 +11536,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -11906,7 +11569,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -11962,7 +11625,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -11974,26 +11637,26 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -12003,7 +11666,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetIo()) { @@ -12031,34 +11694,18 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class get_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("get_args"); - } - - public static class get_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField COLUMN_FIELD_DESC = new org.apache.thrift.protocol.TField("column", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2); + private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3); /** * name of table @@ -12074,7 +11721,7 @@ public class Hbase { public ByteBuffer column; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -12148,17 +11795,17 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.COLUMN, new org.apache.thrift.meta_data.FieldMetaData("column", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(get_args.class, metaDataMap); } public get_args() { @@ -12205,11 +11852,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -12217,7 +11864,7 @@ public class Hbase { * name of table */ public get_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -12230,7 +11877,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -12245,11 +11892,11 @@ public class Hbase { * row key */ public byte[] getRow() { - setRow(org.apache.thrift.TBaseHelper.rightSize(row)); - return row == null ? null : row.array(); + setRow(TBaseHelper.rightSize(row)); + return row.array(); } - public ByteBuffer bufferForRow() { + public ByteBuffer BufferForRow() { return row; } @@ -12257,7 +11904,7 @@ public class Hbase { * row key */ public get_args setRow(byte[] row) { - setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + setRow(ByteBuffer.wrap(row)); return this; } @@ -12270,7 +11917,7 @@ public class Hbase { this.row = null; } - /** Returns true if field row is set (has been assigned a value) and false otherwise */ + /** Returns true if field row is set (has been asigned a value) and false otherwise */ public boolean isSetRow() { return this.row != null; } @@ -12285,11 +11932,11 @@ public class Hbase { * column name */ public byte[] getColumn() { - setColumn(org.apache.thrift.TBaseHelper.rightSize(column)); - return column == null ? null : column.array(); + setColumn(TBaseHelper.rightSize(column)); + return column.array(); } - public ByteBuffer bufferForColumn() { + public ByteBuffer BufferForColumn() { return column; } @@ -12297,7 +11944,7 @@ public class Hbase { * column name */ public get_args setColumn(byte[] column) { - setColumn(column == null ? (ByteBuffer)null : ByteBuffer.wrap(column)); + setColumn(ByteBuffer.wrap(column)); return this; } @@ -12310,7 +11957,7 @@ public class Hbase { this.column = null; } - /** Returns true if field column is set (has been assigned a value) and false otherwise */ + /** Returns true if field column is set (has been asigned a value) and false otherwise */ public boolean isSetColumn() { return this.column != null; } @@ -12365,7 +12012,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -12443,7 +12090,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -12453,7 +12100,7 @@ public class Hbase { return lastComparison; } if (isSetRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + lastComparison = TBaseHelper.compareTo(this.row, typedOther.row); if (lastComparison != 0) { return lastComparison; } @@ -12463,7 +12110,7 @@ public class Hbase { return lastComparison; } if (isSetColumn()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, typedOther.column); + lastComparison = TBaseHelper.compareTo(this.column, typedOther.column); if (lastComparison != 0) { return lastComparison; } @@ -12475,39 +12122,39 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.row = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // COLUMN - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.column = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -12517,7 +12164,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -12572,39 +12219,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class get_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("get_result"); - } - - public static class get_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); - private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public List success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -12666,16 +12297,16 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TCell.class)))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, TCell.class)))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(get_result.class, metaDataMap); } public get_result() { @@ -12744,7 +12375,7 @@ public class Hbase { this.success = null; } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return this.success != null; } @@ -12768,7 +12399,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -12812,7 +12443,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -12879,7 +12510,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -12889,7 +12520,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -12901,20 +12532,20 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list30 = iprot.readListBegin(); + TList _list30 = iprot.readListBegin(); this.success = new ArrayList(_list30.size); for (int _i31 = 0; _i31 < _list30.size; ++_i31) { @@ -12926,19 +12557,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -12948,13 +12579,13 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.success.size())); for (TCell _iter33 : this.success) { _iter33.write(oprot); @@ -12995,35 +12626,19 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getVer_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getVer_args"); - } - - public static class getVer_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getVer_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField COLUMN_FIELD_DESC = new org.apache.thrift.protocol.TField("column", org.apache.thrift.protocol.TType.STRING, (short)3); - private static final org.apache.thrift.protocol.TField NUM_VERSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("numVersions", org.apache.thrift.protocol.TType.I32, (short)4); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2); + private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3); + private static final TField NUM_VERSIONS_FIELD_DESC = new TField("numVersions", TType.I32, (short)4); /** * name of table @@ -13043,7 +12658,7 @@ public class Hbase { public int numVersions; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -13125,19 +12740,19 @@ public class Hbase { private static final int __NUMVERSIONS_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.COLUMN, new org.apache.thrift.meta_data.FieldMetaData("column", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.NUM_VERSIONS, new org.apache.thrift.meta_data.FieldMetaData("numVersions", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.NUM_VERSIONS, new FieldMetaData("numVersions", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I32))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVer_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getVer_args.class, metaDataMap); } public getVer_args() { @@ -13192,11 +12807,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -13204,7 +12819,7 @@ public class Hbase { * name of table */ public getVer_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -13217,7 +12832,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -13232,11 +12847,11 @@ public class Hbase { * row key */ public byte[] getRow() { - setRow(org.apache.thrift.TBaseHelper.rightSize(row)); - return row == null ? null : row.array(); + setRow(TBaseHelper.rightSize(row)); + return row.array(); } - public ByteBuffer bufferForRow() { + public ByteBuffer BufferForRow() { return row; } @@ -13244,7 +12859,7 @@ public class Hbase { * row key */ public getVer_args setRow(byte[] row) { - setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + setRow(ByteBuffer.wrap(row)); return this; } @@ -13257,7 +12872,7 @@ public class Hbase { this.row = null; } - /** Returns true if field row is set (has been assigned a value) and false otherwise */ + /** Returns true if field row is set (has been asigned a value) and false otherwise */ public boolean isSetRow() { return this.row != null; } @@ -13272,11 +12887,11 @@ public class Hbase { * column name */ public byte[] getColumn() { - setColumn(org.apache.thrift.TBaseHelper.rightSize(column)); - return column == null ? null : column.array(); + setColumn(TBaseHelper.rightSize(column)); + return column.array(); } - public ByteBuffer bufferForColumn() { + public ByteBuffer BufferForColumn() { return column; } @@ -13284,7 +12899,7 @@ public class Hbase { * column name */ public getVer_args setColumn(byte[] column) { - setColumn(column == null ? (ByteBuffer)null : ByteBuffer.wrap(column)); + setColumn(ByteBuffer.wrap(column)); return this; } @@ -13297,7 +12912,7 @@ public class Hbase { this.column = null; } - /** Returns true if field column is set (has been assigned a value) and false otherwise */ + /** Returns true if field column is set (has been asigned a value) and false otherwise */ public boolean isSetColumn() { return this.column != null; } @@ -13328,7 +12943,7 @@ public class Hbase { __isset_bit_vector.clear(__NUMVERSIONS_ISSET_ID); } - /** Returns true if field numVersions is set (has been assigned a value) and false otherwise */ + /** Returns true if field numVersions is set (has been asigned a value) and false otherwise */ public boolean isSetNumVersions() { return __isset_bit_vector.get(__NUMVERSIONS_ISSET_ID); } @@ -13392,7 +13007,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -13481,7 +13096,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -13491,7 +13106,7 @@ public class Hbase { return lastComparison; } if (isSetRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + lastComparison = TBaseHelper.compareTo(this.row, typedOther.row); if (lastComparison != 0) { return lastComparison; } @@ -13501,7 +13116,7 @@ public class Hbase { return lastComparison; } if (isSetColumn()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, typedOther.column); + lastComparison = TBaseHelper.compareTo(this.column, typedOther.column); if (lastComparison != 0) { return lastComparison; } @@ -13511,7 +13126,7 @@ public class Hbase { return lastComparison; } if (isSetNumVersions()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numVersions, typedOther.numVersions); + lastComparison = TBaseHelper.compareTo(this.numVersions, typedOther.numVersions); if (lastComparison != 0) { return lastComparison; } @@ -13523,47 +13138,47 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.row = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // COLUMN - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.column = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 4: // NUM_VERSIONS - if (field.type == org.apache.thrift.protocol.TType.I32) { + if (field.type == TType.I32) { this.numVersions = iprot.readI32(); setNumVersionsIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -13573,7 +13188,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -13635,41 +13250,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getVer_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getVer_result"); - } - - public static class getVer_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getVer_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); - private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public List success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -13731,16 +13328,16 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TCell.class)))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, TCell.class)))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVer_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getVer_result.class, metaDataMap); } public getVer_result() { @@ -13809,7 +13406,7 @@ public class Hbase { this.success = null; } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return this.success != null; } @@ -13833,7 +13430,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -13877,7 +13474,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -13944,7 +13541,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -13954,7 +13551,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -13966,20 +13563,20 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list34 = iprot.readListBegin(); + TList _list34 = iprot.readListBegin(); this.success = new ArrayList(_list34.size); for (int _i35 = 0; _i35 < _list34.size; ++_i35) { @@ -13991,19 +13588,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -14013,13 +13610,13 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.success.size())); for (TCell _iter37 : this.success) { _iter37.write(oprot); @@ -14060,36 +13657,20 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getVerTs_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getVerTs_args"); - } - - public static class getVerTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getVerTs_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField COLUMN_FIELD_DESC = new org.apache.thrift.protocol.TField("column", org.apache.thrift.protocol.TType.STRING, (short)3); - private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)4); - private static final org.apache.thrift.protocol.TField NUM_VERSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("numVersions", org.apache.thrift.protocol.TType.I32, (short)5); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2); + private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3); + private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4); + private static final TField NUM_VERSIONS_FIELD_DESC = new TField("numVersions", TType.I32, (short)5); /** * name of table @@ -14113,7 +13694,7 @@ public class Hbase { public int numVersions; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -14202,21 +13783,21 @@ public class Hbase { private static final int __NUMVERSIONS_ISSET_ID = 1; private BitSet __isset_bit_vector = new BitSet(2); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.COLUMN, new org.apache.thrift.meta_data.FieldMetaData("column", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); - tmpMap.put(_Fields.NUM_VERSIONS, new org.apache.thrift.meta_data.FieldMetaData("numVersions", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I64))); + tmpMap.put(_Fields.NUM_VERSIONS, new FieldMetaData("numVersions", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I32))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVerTs_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getVerTs_args.class, metaDataMap); } public getVerTs_args() { @@ -14277,11 +13858,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -14289,7 +13870,7 @@ public class Hbase { * name of table */ public getVerTs_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -14302,7 +13883,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -14317,11 +13898,11 @@ public class Hbase { * row key */ public byte[] getRow() { - setRow(org.apache.thrift.TBaseHelper.rightSize(row)); - return row == null ? null : row.array(); + setRow(TBaseHelper.rightSize(row)); + return row.array(); } - public ByteBuffer bufferForRow() { + public ByteBuffer BufferForRow() { return row; } @@ -14329,7 +13910,7 @@ public class Hbase { * row key */ public getVerTs_args setRow(byte[] row) { - setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + setRow(ByteBuffer.wrap(row)); return this; } @@ -14342,7 +13923,7 @@ public class Hbase { this.row = null; } - /** Returns true if field row is set (has been assigned a value) and false otherwise */ + /** Returns true if field row is set (has been asigned a value) and false otherwise */ public boolean isSetRow() { return this.row != null; } @@ -14357,11 +13938,11 @@ public class Hbase { * column name */ public byte[] getColumn() { - setColumn(org.apache.thrift.TBaseHelper.rightSize(column)); - return column == null ? null : column.array(); + setColumn(TBaseHelper.rightSize(column)); + return column.array(); } - public ByteBuffer bufferForColumn() { + public ByteBuffer BufferForColumn() { return column; } @@ -14369,7 +13950,7 @@ public class Hbase { * column name */ public getVerTs_args setColumn(byte[] column) { - setColumn(column == null ? (ByteBuffer)null : ByteBuffer.wrap(column)); + setColumn(ByteBuffer.wrap(column)); return this; } @@ -14382,7 +13963,7 @@ public class Hbase { this.column = null; } - /** Returns true if field column is set (has been assigned a value) and false otherwise */ + /** Returns true if field column is set (has been asigned a value) and false otherwise */ public boolean isSetColumn() { return this.column != null; } @@ -14413,7 +13994,7 @@ public class Hbase { __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); } - /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ + /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */ public boolean isSetTimestamp() { return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); } @@ -14442,7 +14023,7 @@ public class Hbase { __isset_bit_vector.clear(__NUMVERSIONS_ISSET_ID); } - /** Returns true if field numVersions is set (has been assigned a value) and false otherwise */ + /** Returns true if field numVersions is set (has been asigned a value) and false otherwise */ public boolean isSetNumVersions() { return __isset_bit_vector.get(__NUMVERSIONS_ISSET_ID); } @@ -14517,7 +14098,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -14617,7 +14198,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -14627,7 +14208,7 @@ public class Hbase { return lastComparison; } if (isSetRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + lastComparison = TBaseHelper.compareTo(this.row, typedOther.row); if (lastComparison != 0) { return lastComparison; } @@ -14637,7 +14218,7 @@ public class Hbase { return lastComparison; } if (isSetColumn()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, typedOther.column); + lastComparison = TBaseHelper.compareTo(this.column, typedOther.column); if (lastComparison != 0) { return lastComparison; } @@ -14647,7 +14228,7 @@ public class Hbase { return lastComparison; } if (isSetTimestamp()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + lastComparison = TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); if (lastComparison != 0) { return lastComparison; } @@ -14657,7 +14238,7 @@ public class Hbase { return lastComparison; } if (isSetNumVersions()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numVersions, typedOther.numVersions); + lastComparison = TBaseHelper.compareTo(this.numVersions, typedOther.numVersions); if (lastComparison != 0) { return lastComparison; } @@ -14669,55 +14250,55 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.row = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // COLUMN - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.column = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 4: // TIMESTAMP - if (field.type == org.apache.thrift.protocol.TType.I64) { + if (field.type == TType.I64) { this.timestamp = iprot.readI64(); setTimestampIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 5: // NUM_VERSIONS - if (field.type == org.apache.thrift.protocol.TType.I32) { + if (field.type == TType.I32) { this.numVersions = iprot.readI32(); setNumVersionsIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -14727,7 +14308,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -14796,39 +14377,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getVerTs_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getVerTs_result"); - } - - public static class getVerTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getVerTs_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); - private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public List success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -14890,16 +14455,16 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TCell.class)))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, TCell.class)))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVerTs_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getVerTs_result.class, metaDataMap); } public getVerTs_result() { @@ -14968,7 +14533,7 @@ public class Hbase { this.success = null; } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return this.success != null; } @@ -14992,7 +14557,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -15036,7 +14601,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -15103,7 +14668,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -15113,7 +14678,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -15125,20 +14690,20 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list38 = iprot.readListBegin(); + TList _list38 = iprot.readListBegin(); this.success = new ArrayList(_list38.size); for (int _i39 = 0; _i39 < _list38.size; ++_i39) { @@ -15150,19 +14715,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -15172,13 +14737,13 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.success.size())); for (TCell _iter41 : this.success) { _iter41.write(oprot); @@ -15219,33 +14784,17 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getRow_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getRow_args"); - } - - public static class getRow_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRow_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2); /** * name of table @@ -15257,7 +14806,7 @@ public class Hbase { public ByteBuffer row; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -15325,15 +14874,15 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRow_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getRow_args.class, metaDataMap); } public getRow_args() { @@ -15374,11 +14923,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -15386,7 +14935,7 @@ public class Hbase { * name of table */ public getRow_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -15399,7 +14948,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -15414,11 +14963,11 @@ public class Hbase { * row key */ public byte[] getRow() { - setRow(org.apache.thrift.TBaseHelper.rightSize(row)); - return row == null ? null : row.array(); + setRow(TBaseHelper.rightSize(row)); + return row.array(); } - public ByteBuffer bufferForRow() { + public ByteBuffer BufferForRow() { return row; } @@ -15426,7 +14975,7 @@ public class Hbase { * row key */ public getRow_args setRow(byte[] row) { - setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + setRow(ByteBuffer.wrap(row)); return this; } @@ -15439,7 +14988,7 @@ public class Hbase { this.row = null; } - /** Returns true if field row is set (has been assigned a value) and false otherwise */ + /** Returns true if field row is set (has been asigned a value) and false otherwise */ public boolean isSetRow() { return this.row != null; } @@ -15483,7 +15032,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -15550,7 +15099,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -15560,7 +15109,7 @@ public class Hbase { return lastComparison; } if (isSetRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + lastComparison = TBaseHelper.compareTo(this.row, typedOther.row); if (lastComparison != 0) { return lastComparison; } @@ -15572,32 +15121,32 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.row = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -15607,7 +15156,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -15649,39 +15198,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getRow_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getRow_result"); - } - - public static class getRow_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRow_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); - private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public List success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -15743,16 +15276,16 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowResult.class)))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, TRowResult.class)))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRow_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getRow_result.class, metaDataMap); } public getRow_result() { @@ -15821,7 +15354,7 @@ public class Hbase { this.success = null; } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return this.success != null; } @@ -15845,7 +15378,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -15889,7 +15422,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -15956,7 +15489,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -15966,7 +15499,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -15978,20 +15511,20 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list42 = iprot.readListBegin(); + TList _list42 = iprot.readListBegin(); this.success = new ArrayList(_list42.size); for (int _i43 = 0; _i43 < _list42.size; ++_i43) { @@ -16003,19 +15536,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -16025,13 +15558,13 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.success.size())); for (TRowResult _iter45 : this.success) { _iter45.write(oprot); @@ -16072,34 +15605,18 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getRowWithColumns_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumns_args"); - } - - public static class getRowWithColumns_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowWithColumns_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)3); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2); + private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3); /** * name of table @@ -16115,7 +15632,7 @@ public class Hbase { public List columns; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -16189,18 +15706,18 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new FieldValueMetaData(TType.STRING , "Text")))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumns_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getRowWithColumns_args.class, metaDataMap); } public getRowWithColumns_args() { @@ -16251,11 +15768,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -16263,7 +15780,7 @@ public class Hbase { * name of table */ public getRowWithColumns_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -16276,7 +15793,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -16291,11 +15808,11 @@ public class Hbase { * row key */ public byte[] getRow() { - setRow(org.apache.thrift.TBaseHelper.rightSize(row)); - return row == null ? null : row.array(); + setRow(TBaseHelper.rightSize(row)); + return row.array(); } - public ByteBuffer bufferForRow() { + public ByteBuffer BufferForRow() { return row; } @@ -16303,7 +15820,7 @@ public class Hbase { * row key */ public getRowWithColumns_args setRow(byte[] row) { - setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + setRow(ByteBuffer.wrap(row)); return this; } @@ -16316,7 +15833,7 @@ public class Hbase { this.row = null; } - /** Returns true if field row is set (has been assigned a value) and false otherwise */ + /** Returns true if field row is set (has been asigned a value) and false otherwise */ public boolean isSetRow() { return this.row != null; } @@ -16361,7 +15878,7 @@ public class Hbase { this.columns = null; } - /** Returns true if field columns is set (has been assigned a value) and false otherwise */ + /** Returns true if field columns is set (has been asigned a value) and false otherwise */ public boolean isSetColumns() { return this.columns != null; } @@ -16416,7 +15933,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -16494,7 +16011,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -16504,7 +16021,7 @@ public class Hbase { return lastComparison; } if (isSetRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + lastComparison = TBaseHelper.compareTo(this.row, typedOther.row); if (lastComparison != 0) { return lastComparison; } @@ -16514,7 +16031,7 @@ public class Hbase { return lastComparison; } if (isSetColumns()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns); + lastComparison = TBaseHelper.compareTo(this.columns, typedOther.columns); if (lastComparison != 0) { return lastComparison; } @@ -16526,34 +16043,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.row = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // COLUMNS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list46 = iprot.readListBegin(); + TList _list46 = iprot.readListBegin(); this.columns = new ArrayList(_list46.size); for (int _i47 = 0; _i47 < _list46.size; ++_i47) { @@ -16564,11 +16081,11 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -16578,7 +16095,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -16595,7 +16112,7 @@ public class Hbase { if (this.columns != null) { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); + oprot.writeListBegin(new TList(TType.STRING, this.columns.size())); for (ByteBuffer _iter49 : this.columns) { oprot.writeBinary(_iter49); @@ -16640,39 +16157,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getRowWithColumns_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumns_result"); - } - - public static class getRowWithColumns_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowWithColumns_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); - private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public List success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -16734,16 +16235,16 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowResult.class)))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, TRowResult.class)))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumns_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getRowWithColumns_result.class, metaDataMap); } public getRowWithColumns_result() { @@ -16812,7 +16313,7 @@ public class Hbase { this.success = null; } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return this.success != null; } @@ -16836,7 +16337,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -16880,7 +16381,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -16947,7 +16448,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -16957,7 +16458,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -16969,20 +16470,20 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list50 = iprot.readListBegin(); + TList _list50 = iprot.readListBegin(); this.success = new ArrayList(_list50.size); for (int _i51 = 0; _i51 < _list50.size; ++_i51) { @@ -16994,19 +16495,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -17016,13 +16517,13 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.success.size())); for (TRowResult _iter53 : this.success) { _iter53.write(oprot); @@ -17063,34 +16564,18 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getRowTs_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getRowTs_args"); - } - - public static class getRowTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowTs_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)3); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2); + private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3); /** * name of the table @@ -17106,7 +16591,7 @@ public class Hbase { public long timestamp; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of the table */ @@ -17182,17 +16667,17 @@ public class Hbase { private static final int __TIMESTAMP_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I64))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowTs_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getRowTs_args.class, metaDataMap); } public getRowTs_args() { @@ -17241,11 +16726,11 @@ public class Hbase { * name of the table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -17253,7 +16738,7 @@ public class Hbase { * name of the table */ public getRowTs_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -17266,7 +16751,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -17281,11 +16766,11 @@ public class Hbase { * row key */ public byte[] getRow() { - setRow(org.apache.thrift.TBaseHelper.rightSize(row)); - return row == null ? null : row.array(); + setRow(TBaseHelper.rightSize(row)); + return row.array(); } - public ByteBuffer bufferForRow() { + public ByteBuffer BufferForRow() { return row; } @@ -17293,7 +16778,7 @@ public class Hbase { * row key */ public getRowTs_args setRow(byte[] row) { - setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + setRow(ByteBuffer.wrap(row)); return this; } @@ -17306,7 +16791,7 @@ public class Hbase { this.row = null; } - /** Returns true if field row is set (has been assigned a value) and false otherwise */ + /** Returns true if field row is set (has been asigned a value) and false otherwise */ public boolean isSetRow() { return this.row != null; } @@ -17337,7 +16822,7 @@ public class Hbase { __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); } - /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ + /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */ public boolean isSetTimestamp() { return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); } @@ -17390,7 +16875,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -17468,7 +16953,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -17478,7 +16963,7 @@ public class Hbase { return lastComparison; } if (isSetRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + lastComparison = TBaseHelper.compareTo(this.row, typedOther.row); if (lastComparison != 0) { return lastComparison; } @@ -17488,7 +16973,7 @@ public class Hbase { return lastComparison; } if (isSetTimestamp()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + lastComparison = TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); if (lastComparison != 0) { return lastComparison; } @@ -17500,40 +16985,40 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.row = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // TIMESTAMP - if (field.type == org.apache.thrift.protocol.TType.I64) { + if (field.type == TType.I64) { this.timestamp = iprot.readI64(); setTimestampIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -17543,7 +17028,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -17592,41 +17077,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getRowTs_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getRowTs_result"); - } - - public static class getRowTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowTs_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); - private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public List success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -17688,16 +17155,16 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowResult.class)))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, TRowResult.class)))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowTs_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getRowTs_result.class, metaDataMap); } public getRowTs_result() { @@ -17766,7 +17233,7 @@ public class Hbase { this.success = null; } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return this.success != null; } @@ -17790,7 +17257,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -17834,7 +17301,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -17901,7 +17368,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -17911,7 +17378,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -17923,20 +17390,20 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list54 = iprot.readListBegin(); + TList _list54 = iprot.readListBegin(); this.success = new ArrayList(_list54.size); for (int _i55 = 0; _i55 < _list54.size; ++_i55) { @@ -17948,19 +17415,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -17970,13 +17437,13 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.success.size())); for (TRowResult _iter57 : this.success) { _iter57.write(oprot); @@ -18017,35 +17484,19 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getRowWithColumnsTs_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumnsTs_args"); - } - - public static class getRowWithColumnsTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowWithColumnsTs_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)3); - private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)4); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2); + private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3); + private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4); /** * name of table @@ -18062,7 +17513,7 @@ public class Hbase { public long timestamp; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -18141,20 +17592,20 @@ public class Hbase { private static final int __TIMESTAMP_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); - tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new FieldValueMetaData(TType.STRING , "Text")))); + tmpMap.put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I64))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumnsTs_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getRowWithColumnsTs_args.class, metaDataMap); } public getRowWithColumnsTs_args() { @@ -18213,11 +17664,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -18225,7 +17676,7 @@ public class Hbase { * name of table */ public getRowWithColumnsTs_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -18238,7 +17689,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -18253,11 +17704,11 @@ public class Hbase { * row key */ public byte[] getRow() { - setRow(org.apache.thrift.TBaseHelper.rightSize(row)); - return row == null ? null : row.array(); + setRow(TBaseHelper.rightSize(row)); + return row.array(); } - public ByteBuffer bufferForRow() { + public ByteBuffer BufferForRow() { return row; } @@ -18265,7 +17716,7 @@ public class Hbase { * row key */ public getRowWithColumnsTs_args setRow(byte[] row) { - setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + setRow(ByteBuffer.wrap(row)); return this; } @@ -18278,7 +17729,7 @@ public class Hbase { this.row = null; } - /** Returns true if field row is set (has been assigned a value) and false otherwise */ + /** Returns true if field row is set (has been asigned a value) and false otherwise */ public boolean isSetRow() { return this.row != null; } @@ -18323,7 +17774,7 @@ public class Hbase { this.columns = null; } - /** Returns true if field columns is set (has been assigned a value) and false otherwise */ + /** Returns true if field columns is set (has been asigned a value) and false otherwise */ public boolean isSetColumns() { return this.columns != null; } @@ -18348,7 +17799,7 @@ public class Hbase { __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); } - /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ + /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */ public boolean isSetTimestamp() { return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); } @@ -18412,7 +17863,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -18501,7 +17952,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -18511,7 +17962,7 @@ public class Hbase { return lastComparison; } if (isSetRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + lastComparison = TBaseHelper.compareTo(this.row, typedOther.row); if (lastComparison != 0) { return lastComparison; } @@ -18521,7 +17972,7 @@ public class Hbase { return lastComparison; } if (isSetColumns()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns); + lastComparison = TBaseHelper.compareTo(this.columns, typedOther.columns); if (lastComparison != 0) { return lastComparison; } @@ -18531,7 +17982,7 @@ public class Hbase { return lastComparison; } if (isSetTimestamp()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + lastComparison = TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); if (lastComparison != 0) { return lastComparison; } @@ -18543,34 +17994,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.row = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // COLUMNS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list58 = iprot.readListBegin(); + TList _list58 = iprot.readListBegin(); this.columns = new ArrayList(_list58.size); for (int _i59 = 0; _i59 < _list58.size; ++_i59) { @@ -18581,19 +18032,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 4: // TIMESTAMP - if (field.type == org.apache.thrift.protocol.TType.I64) { + if (field.type == TType.I64) { this.timestamp = iprot.readI64(); setTimestampIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -18603,7 +18054,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -18620,7 +18071,7 @@ public class Hbase { if (this.columns != null) { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); + oprot.writeListBegin(new TList(TType.STRING, this.columns.size())); for (ByteBuffer _iter61 : this.columns) { oprot.writeBinary(_iter61); @@ -18672,41 +18123,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getRowWithColumnsTs_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumnsTs_result"); - } - - public static class getRowWithColumnsTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowWithColumnsTs_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); - private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public List success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -18768,16 +18201,16 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowResult.class)))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, TRowResult.class)))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumnsTs_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getRowWithColumnsTs_result.class, metaDataMap); } public getRowWithColumnsTs_result() { @@ -18846,7 +18279,7 @@ public class Hbase { this.success = null; } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return this.success != null; } @@ -18870,7 +18303,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -18914,7 +18347,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -18981,7 +18414,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -18991,7 +18424,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -19003,20 +18436,20 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list62 = iprot.readListBegin(); + TList _list62 = iprot.readListBegin(); this.success = new ArrayList(_list62.size); for (int _i63 = 0; _i63 < _list62.size; ++_i63) { @@ -19028,19 +18461,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -19050,13 +18483,13 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.success.size())); for (TRowResult _iter65 : this.success) { _iter65.write(oprot); @@ -19097,33 +18530,17 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getRows_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getRows_args"); - } - - public static class getRows_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRows_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROWS_FIELD_DESC = new org.apache.thrift.protocol.TField("rows", org.apache.thrift.protocol.TType.LIST, (short)2); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROWS_FIELD_DESC = new TField("rows", TType.LIST, (short)2); /** * name of table @@ -19135,7 +18552,7 @@ public class Hbase { public List rows; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -19203,16 +18620,16 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROWS, new org.apache.thrift.meta_data.FieldMetaData("rows", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROWS, new FieldMetaData("rows", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new FieldValueMetaData(TType.STRING , "Text")))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRows_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getRows_args.class, metaDataMap); } public getRows_args() { @@ -19257,11 +18674,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -19269,7 +18686,7 @@ public class Hbase { * name of table */ public getRows_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -19282,7 +18699,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -19327,7 +18744,7 @@ public class Hbase { this.rows = null; } - /** Returns true if field rows is set (has been assigned a value) and false otherwise */ + /** Returns true if field rows is set (has been asigned a value) and false otherwise */ public boolean isSetRows() { return this.rows != null; } @@ -19371,7 +18788,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -19438,7 +18855,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -19448,7 +18865,7 @@ public class Hbase { return lastComparison; } if (isSetRows()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rows, typedOther.rows); + lastComparison = TBaseHelper.compareTo(this.rows, typedOther.rows); if (lastComparison != 0) { return lastComparison; } @@ -19460,27 +18877,27 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROWS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list66 = iprot.readListBegin(); + TList _list66 = iprot.readListBegin(); this.rows = new ArrayList(_list66.size); for (int _i67 = 0; _i67 < _list66.size; ++_i67) { @@ -19491,11 +18908,11 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -19505,7 +18922,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -19517,7 +18934,7 @@ public class Hbase { if (this.rows != null) { oprot.writeFieldBegin(ROWS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.rows.size())); + oprot.writeListBegin(new TList(TType.STRING, this.rows.size())); for (ByteBuffer _iter69 : this.rows) { oprot.writeBinary(_iter69); @@ -19554,39 +18971,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getRows_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getRows_result"); - } - - public static class getRows_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRows_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); - private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public List success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -19648,16 +19049,16 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowResult.class)))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, TRowResult.class)))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRows_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getRows_result.class, metaDataMap); } public getRows_result() { @@ -19726,7 +19127,7 @@ public class Hbase { this.success = null; } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return this.success != null; } @@ -19750,7 +19151,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -19794,7 +19195,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -19861,7 +19262,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -19871,7 +19272,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -19883,20 +19284,20 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list70 = iprot.readListBegin(); + TList _list70 = iprot.readListBegin(); this.success = new ArrayList(_list70.size); for (int _i71 = 0; _i71 < _list70.size; ++_i71) { @@ -19908,19 +19309,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -19930,13 +19331,13 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.success.size())); for (TRowResult _iter73 : this.success) { _iter73.write(oprot); @@ -19977,34 +19378,18 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getRowsWithColumns_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getRowsWithColumns_args"); - } - - public static class getRowsWithColumns_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowsWithColumns_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROWS_FIELD_DESC = new org.apache.thrift.protocol.TField("rows", org.apache.thrift.protocol.TType.LIST, (short)2); - private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)3); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROWS_FIELD_DESC = new TField("rows", TType.LIST, (short)2); + private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3); /** * name of table @@ -20020,7 +19405,7 @@ public class Hbase { public List columns; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -20094,19 +19479,19 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROWS, new org.apache.thrift.meta_data.FieldMetaData("rows", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); - tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROWS, new FieldMetaData("rows", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new FieldValueMetaData(TType.STRING , "Text")))); + tmpMap.put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new FieldValueMetaData(TType.STRING , "Text")))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowsWithColumns_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getRowsWithColumns_args.class, metaDataMap); } public getRowsWithColumns_args() { @@ -20161,11 +19546,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -20173,7 +19558,7 @@ public class Hbase { * name of table */ public getRowsWithColumns_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -20186,7 +19571,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -20231,7 +19616,7 @@ public class Hbase { this.rows = null; } - /** Returns true if field rows is set (has been assigned a value) and false otherwise */ + /** Returns true if field rows is set (has been asigned a value) and false otherwise */ public boolean isSetRows() { return this.rows != null; } @@ -20276,7 +19661,7 @@ public class Hbase { this.columns = null; } - /** Returns true if field columns is set (has been assigned a value) and false otherwise */ + /** Returns true if field columns is set (has been asigned a value) and false otherwise */ public boolean isSetColumns() { return this.columns != null; } @@ -20331,7 +19716,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -20409,7 +19794,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -20419,7 +19804,7 @@ public class Hbase { return lastComparison; } if (isSetRows()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rows, typedOther.rows); + lastComparison = TBaseHelper.compareTo(this.rows, typedOther.rows); if (lastComparison != 0) { return lastComparison; } @@ -20429,7 +19814,7 @@ public class Hbase { return lastComparison; } if (isSetColumns()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns); + lastComparison = TBaseHelper.compareTo(this.columns, typedOther.columns); if (lastComparison != 0) { return lastComparison; } @@ -20441,27 +19826,27 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROWS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list74 = iprot.readListBegin(); + TList _list74 = iprot.readListBegin(); this.rows = new ArrayList(_list74.size); for (int _i75 = 0; _i75 < _list74.size; ++_i75) { @@ -20472,13 +19857,13 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // COLUMNS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list77 = iprot.readListBegin(); + TList _list77 = iprot.readListBegin(); this.columns = new ArrayList(_list77.size); for (int _i78 = 0; _i78 < _list77.size; ++_i78) { @@ -20489,11 +19874,11 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -20503,7 +19888,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -20515,7 +19900,7 @@ public class Hbase { if (this.rows != null) { oprot.writeFieldBegin(ROWS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.rows.size())); + oprot.writeListBegin(new TList(TType.STRING, this.rows.size())); for (ByteBuffer _iter80 : this.rows) { oprot.writeBinary(_iter80); @@ -20527,7 +19912,7 @@ public class Hbase { if (this.columns != null) { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); + oprot.writeListBegin(new TList(TType.STRING, this.columns.size())); for (ByteBuffer _iter81 : this.columns) { oprot.writeBinary(_iter81); @@ -20572,39 +19957,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getRowsWithColumns_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getRowsWithColumns_result"); - } - - public static class getRowsWithColumns_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowsWithColumns_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); - private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public List success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -20666,16 +20035,16 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowResult.class)))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, TRowResult.class)))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowsWithColumns_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getRowsWithColumns_result.class, metaDataMap); } public getRowsWithColumns_result() { @@ -20744,7 +20113,7 @@ public class Hbase { this.success = null; } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return this.success != null; } @@ -20768,7 +20137,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -20812,7 +20181,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -20879,7 +20248,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -20889,7 +20258,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -20901,20 +20270,20 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list82 = iprot.readListBegin(); + TList _list82 = iprot.readListBegin(); this.success = new ArrayList(_list82.size); for (int _i83 = 0; _i83 < _list82.size; ++_i83) { @@ -20926,19 +20295,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -20948,13 +20317,13 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.success.size())); for (TRowResult _iter85 : this.success) { _iter85.write(oprot); @@ -20995,34 +20364,18 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getRowsTs_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getRowsTs_args"); - } - - public static class getRowsTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowsTs_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROWS_FIELD_DESC = new org.apache.thrift.protocol.TField("rows", org.apache.thrift.protocol.TType.LIST, (short)2); - private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)3); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROWS_FIELD_DESC = new TField("rows", TType.LIST, (short)2); + private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3); /** * name of the table @@ -21038,7 +20391,7 @@ public class Hbase { public long timestamp; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of the table */ @@ -21114,18 +20467,18 @@ public class Hbase { private static final int __TIMESTAMP_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROWS, new org.apache.thrift.meta_data.FieldMetaData("rows", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); - tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROWS, new FieldMetaData("rows", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new FieldValueMetaData(TType.STRING , "Text")))); + tmpMap.put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I64))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowsTs_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getRowsTs_args.class, metaDataMap); } public getRowsTs_args() { @@ -21178,11 +20531,11 @@ public class Hbase { * name of the table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -21190,7 +20543,7 @@ public class Hbase { * name of the table */ public getRowsTs_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -21203,7 +20556,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -21248,7 +20601,7 @@ public class Hbase { this.rows = null; } - /** Returns true if field rows is set (has been assigned a value) and false otherwise */ + /** Returns true if field rows is set (has been asigned a value) and false otherwise */ public boolean isSetRows() { return this.rows != null; } @@ -21279,7 +20632,7 @@ public class Hbase { __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); } - /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ + /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */ public boolean isSetTimestamp() { return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); } @@ -21332,7 +20685,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -21410,7 +20763,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -21420,7 +20773,7 @@ public class Hbase { return lastComparison; } if (isSetRows()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rows, typedOther.rows); + lastComparison = TBaseHelper.compareTo(this.rows, typedOther.rows); if (lastComparison != 0) { return lastComparison; } @@ -21430,7 +20783,7 @@ public class Hbase { return lastComparison; } if (isSetTimestamp()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + lastComparison = TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); if (lastComparison != 0) { return lastComparison; } @@ -21442,27 +20795,27 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROWS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list86 = iprot.readListBegin(); + TList _list86 = iprot.readListBegin(); this.rows = new ArrayList(_list86.size); for (int _i87 = 0; _i87 < _list86.size; ++_i87) { @@ -21473,19 +20826,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // TIMESTAMP - if (field.type == org.apache.thrift.protocol.TType.I64) { + if (field.type == TType.I64) { this.timestamp = iprot.readI64(); setTimestampIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -21495,7 +20848,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -21507,7 +20860,7 @@ public class Hbase { if (this.rows != null) { oprot.writeFieldBegin(ROWS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.rows.size())); + oprot.writeListBegin(new TList(TType.STRING, this.rows.size())); for (ByteBuffer _iter89 : this.rows) { oprot.writeBinary(_iter89); @@ -21551,41 +20904,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getRowsTs_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getRowsTs_result"); - } - - public static class getRowsTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowsTs_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); - private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public List success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -21647,16 +20982,16 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowResult.class)))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, TRowResult.class)))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowsTs_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getRowsTs_result.class, metaDataMap); } public getRowsTs_result() { @@ -21725,7 +21060,7 @@ public class Hbase { this.success = null; } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return this.success != null; } @@ -21749,7 +21084,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -21793,7 +21128,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -21860,7 +21195,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -21870,7 +21205,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -21882,20 +21217,20 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list90 = iprot.readListBegin(); + TList _list90 = iprot.readListBegin(); this.success = new ArrayList(_list90.size); for (int _i91 = 0; _i91 < _list90.size; ++_i91) { @@ -21907,19 +21242,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -21929,13 +21264,13 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.success.size())); for (TRowResult _iter93 : this.success) { _iter93.write(oprot); @@ -21976,35 +21311,19 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getRowsWithColumnsTs_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getRowsWithColumnsTs_args"); - } - - public static class getRowsWithColumnsTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowsWithColumnsTs_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROWS_FIELD_DESC = new org.apache.thrift.protocol.TField("rows", org.apache.thrift.protocol.TType.LIST, (short)2); - private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)3); - private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)4); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROWS_FIELD_DESC = new TField("rows", TType.LIST, (short)2); + private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3); + private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4); /** * name of table @@ -22021,7 +21340,7 @@ public class Hbase { public long timestamp; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -22100,21 +21419,21 @@ public class Hbase { private static final int __TIMESTAMP_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROWS, new org.apache.thrift.meta_data.FieldMetaData("rows", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); - tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); - tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROWS, new FieldMetaData("rows", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new FieldValueMetaData(TType.STRING , "Text")))); + tmpMap.put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new FieldValueMetaData(TType.STRING , "Text")))); + tmpMap.put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I64))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowsWithColumnsTs_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getRowsWithColumnsTs_args.class, metaDataMap); } public getRowsWithColumnsTs_args() { @@ -22177,11 +21496,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -22189,7 +21508,7 @@ public class Hbase { * name of table */ public getRowsWithColumnsTs_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -22202,7 +21521,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -22247,7 +21566,7 @@ public class Hbase { this.rows = null; } - /** Returns true if field rows is set (has been assigned a value) and false otherwise */ + /** Returns true if field rows is set (has been asigned a value) and false otherwise */ public boolean isSetRows() { return this.rows != null; } @@ -22292,7 +21611,7 @@ public class Hbase { this.columns = null; } - /** Returns true if field columns is set (has been assigned a value) and false otherwise */ + /** Returns true if field columns is set (has been asigned a value) and false otherwise */ public boolean isSetColumns() { return this.columns != null; } @@ -22317,7 +21636,7 @@ public class Hbase { __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); } - /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ + /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */ public boolean isSetTimestamp() { return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); } @@ -22381,7 +21700,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -22470,7 +21789,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -22480,7 +21799,7 @@ public class Hbase { return lastComparison; } if (isSetRows()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rows, typedOther.rows); + lastComparison = TBaseHelper.compareTo(this.rows, typedOther.rows); if (lastComparison != 0) { return lastComparison; } @@ -22490,7 +21809,7 @@ public class Hbase { return lastComparison; } if (isSetColumns()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns); + lastComparison = TBaseHelper.compareTo(this.columns, typedOther.columns); if (lastComparison != 0) { return lastComparison; } @@ -22500,7 +21819,7 @@ public class Hbase { return lastComparison; } if (isSetTimestamp()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + lastComparison = TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); if (lastComparison != 0) { return lastComparison; } @@ -22512,27 +21831,27 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROWS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list94 = iprot.readListBegin(); + TList _list94 = iprot.readListBegin(); this.rows = new ArrayList(_list94.size); for (int _i95 = 0; _i95 < _list94.size; ++_i95) { @@ -22543,13 +21862,13 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // COLUMNS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list97 = iprot.readListBegin(); + TList _list97 = iprot.readListBegin(); this.columns = new ArrayList(_list97.size); for (int _i98 = 0; _i98 < _list97.size; ++_i98) { @@ -22560,19 +21879,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 4: // TIMESTAMP - if (field.type == org.apache.thrift.protocol.TType.I64) { + if (field.type == TType.I64) { this.timestamp = iprot.readI64(); setTimestampIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -22582,7 +21901,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -22594,7 +21913,7 @@ public class Hbase { if (this.rows != null) { oprot.writeFieldBegin(ROWS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.rows.size())); + oprot.writeListBegin(new TList(TType.STRING, this.rows.size())); for (ByteBuffer _iter100 : this.rows) { oprot.writeBinary(_iter100); @@ -22606,7 +21925,7 @@ public class Hbase { if (this.columns != null) { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); + oprot.writeListBegin(new TList(TType.STRING, this.columns.size())); for (ByteBuffer _iter101 : this.columns) { oprot.writeBinary(_iter101); @@ -22658,41 +21977,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class getRowsWithColumnsTs_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("getRowsWithColumnsTs_result"); - } - - public static class getRowsWithColumnsTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowsWithColumnsTs_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); - private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public List success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -22754,16 +22055,16 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowResult.class)))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, TRowResult.class)))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowsWithColumnsTs_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(getRowsWithColumnsTs_result.class, metaDataMap); } public getRowsWithColumnsTs_result() { @@ -22832,7 +22133,7 @@ public class Hbase { this.success = null; } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return this.success != null; } @@ -22856,7 +22157,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -22900,7 +22201,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -22967,7 +22268,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -22977,7 +22278,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -22989,20 +22290,20 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list102 = iprot.readListBegin(); + TList _list102 = iprot.readListBegin(); this.success = new ArrayList(_list102.size); for (int _i103 = 0; _i103 < _list102.size; ++_i103) { @@ -23014,19 +22315,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -23036,13 +22337,13 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.success.size())); for (TRowResult _iter105 : this.success) { _iter105.write(oprot); @@ -23083,34 +22384,18 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class mutateRow_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("mutateRow_args"); - } - - public static class mutateRow_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("mutateRow_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField MUTATIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("mutations", org.apache.thrift.protocol.TType.LIST, (short)3); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2); + private static final TField MUTATIONS_FIELD_DESC = new TField("mutations", TType.LIST, (short)3); /** * name of table @@ -23126,7 +22411,7 @@ public class Hbase { public List mutations; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -23200,18 +22485,18 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.MUTATIONS, new org.apache.thrift.meta_data.FieldMetaData("mutations", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Mutation.class)))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.MUTATIONS, new FieldMetaData("mutations", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, Mutation.class)))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRow_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(mutateRow_args.class, metaDataMap); } public mutateRow_args() { @@ -23262,11 +22547,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -23274,7 +22559,7 @@ public class Hbase { * name of table */ public mutateRow_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -23287,7 +22572,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -23302,11 +22587,11 @@ public class Hbase { * row key */ public byte[] getRow() { - setRow(org.apache.thrift.TBaseHelper.rightSize(row)); - return row == null ? null : row.array(); + setRow(TBaseHelper.rightSize(row)); + return row.array(); } - public ByteBuffer bufferForRow() { + public ByteBuffer BufferForRow() { return row; } @@ -23314,7 +22599,7 @@ public class Hbase { * row key */ public mutateRow_args setRow(byte[] row) { - setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + setRow(ByteBuffer.wrap(row)); return this; } @@ -23327,7 +22612,7 @@ public class Hbase { this.row = null; } - /** Returns true if field row is set (has been assigned a value) and false otherwise */ + /** Returns true if field row is set (has been asigned a value) and false otherwise */ public boolean isSetRow() { return this.row != null; } @@ -23372,7 +22657,7 @@ public class Hbase { this.mutations = null; } - /** Returns true if field mutations is set (has been assigned a value) and false otherwise */ + /** Returns true if field mutations is set (has been asigned a value) and false otherwise */ public boolean isSetMutations() { return this.mutations != null; } @@ -23427,7 +22712,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -23505,7 +22790,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -23515,7 +22800,7 @@ public class Hbase { return lastComparison; } if (isSetRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + lastComparison = TBaseHelper.compareTo(this.row, typedOther.row); if (lastComparison != 0) { return lastComparison; } @@ -23525,7 +22810,7 @@ public class Hbase { return lastComparison; } if (isSetMutations()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.mutations, typedOther.mutations); + lastComparison = TBaseHelper.compareTo(this.mutations, typedOther.mutations); if (lastComparison != 0) { return lastComparison; } @@ -23537,34 +22822,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.row = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // MUTATIONS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list106 = iprot.readListBegin(); + TList _list106 = iprot.readListBegin(); this.mutations = new ArrayList(_list106.size); for (int _i107 = 0; _i107 < _list106.size; ++_i107) { @@ -23576,11 +22861,11 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -23590,7 +22875,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -23607,7 +22892,7 @@ public class Hbase { if (this.mutations != null) { oprot.writeFieldBegin(MUTATIONS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.mutations.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.mutations.size())); for (Mutation _iter109 : this.mutations) { _iter109.write(oprot); @@ -23652,39 +22937,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class mutateRow_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("mutateRow_result"); - } - - public static class mutateRow_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("mutateRow_result"); - - 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.protocol.TField IA_FIELD_DESC = new org.apache.thrift.protocol.TField("ia", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); + private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2); public IOError io; public IllegalArgument ia; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { IO((short)1, "io"), IA((short)2, "ia"); @@ -23746,15 +23015,15 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); - tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); + tmpMap.put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRow_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(mutateRow_result.class, metaDataMap); } public mutateRow_result() { @@ -23804,7 +23073,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -23828,7 +23097,7 @@ public class Hbase { this.ia = null; } - /** Returns true if field ia is set (has been assigned a value) and false otherwise */ + /** Returns true if field ia is set (has been asigned a value) and false otherwise */ public boolean isSetIa() { return this.ia != null; } @@ -23872,7 +23141,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -23939,7 +23208,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -23949,7 +23218,7 @@ public class Hbase { return lastComparison; } if (isSetIa()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, typedOther.ia); + lastComparison = TBaseHelper.compareTo(this.ia, typedOther.ia); if (lastComparison != 0) { return lastComparison; } @@ -23961,34 +23230,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // IA - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.ia = new IllegalArgument(); this.ia.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -23998,7 +23267,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetIo()) { @@ -24038,35 +23307,19 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class mutateRowTs_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("mutateRowTs_args"); - } - - public static class mutateRowTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("mutateRowTs_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField MUTATIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("mutations", org.apache.thrift.protocol.TType.LIST, (short)3); - private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)4); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2); + private static final TField MUTATIONS_FIELD_DESC = new TField("mutations", TType.LIST, (short)3); + private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4); /** * name of table @@ -24086,7 +23339,7 @@ public class Hbase { public long timestamp; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -24168,20 +23421,20 @@ public class Hbase { private static final int __TIMESTAMP_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.MUTATIONS, new org.apache.thrift.meta_data.FieldMetaData("mutations", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Mutation.class)))); - tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.MUTATIONS, new FieldMetaData("mutations", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, Mutation.class)))); + tmpMap.put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I64))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRowTs_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(mutateRowTs_args.class, metaDataMap); } public mutateRowTs_args() { @@ -24240,11 +23493,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -24252,7 +23505,7 @@ public class Hbase { * name of table */ public mutateRowTs_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -24265,7 +23518,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -24280,11 +23533,11 @@ public class Hbase { * row key */ public byte[] getRow() { - setRow(org.apache.thrift.TBaseHelper.rightSize(row)); - return row == null ? null : row.array(); + setRow(TBaseHelper.rightSize(row)); + return row.array(); } - public ByteBuffer bufferForRow() { + public ByteBuffer BufferForRow() { return row; } @@ -24292,7 +23545,7 @@ public class Hbase { * row key */ public mutateRowTs_args setRow(byte[] row) { - setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + setRow(ByteBuffer.wrap(row)); return this; } @@ -24305,7 +23558,7 @@ public class Hbase { this.row = null; } - /** Returns true if field row is set (has been assigned a value) and false otherwise */ + /** Returns true if field row is set (has been asigned a value) and false otherwise */ public boolean isSetRow() { return this.row != null; } @@ -24350,7 +23603,7 @@ public class Hbase { this.mutations = null; } - /** Returns true if field mutations is set (has been assigned a value) and false otherwise */ + /** Returns true if field mutations is set (has been asigned a value) and false otherwise */ public boolean isSetMutations() { return this.mutations != null; } @@ -24381,7 +23634,7 @@ public class Hbase { __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); } - /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ + /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */ public boolean isSetTimestamp() { return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); } @@ -24445,7 +23698,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -24534,7 +23787,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -24544,7 +23797,7 @@ public class Hbase { return lastComparison; } if (isSetRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + lastComparison = TBaseHelper.compareTo(this.row, typedOther.row); if (lastComparison != 0) { return lastComparison; } @@ -24554,7 +23807,7 @@ public class Hbase { return lastComparison; } if (isSetMutations()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.mutations, typedOther.mutations); + lastComparison = TBaseHelper.compareTo(this.mutations, typedOther.mutations); if (lastComparison != 0) { return lastComparison; } @@ -24564,7 +23817,7 @@ public class Hbase { return lastComparison; } if (isSetTimestamp()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + lastComparison = TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); if (lastComparison != 0) { return lastComparison; } @@ -24576,34 +23829,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.row = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // MUTATIONS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list110 = iprot.readListBegin(); + TList _list110 = iprot.readListBegin(); this.mutations = new ArrayList(_list110.size); for (int _i111 = 0; _i111 < _list110.size; ++_i111) { @@ -24615,19 +23868,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 4: // TIMESTAMP - if (field.type == org.apache.thrift.protocol.TType.I64) { + if (field.type == TType.I64) { this.timestamp = iprot.readI64(); setTimestampIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -24637,7 +23890,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -24654,7 +23907,7 @@ public class Hbase { if (this.mutations != null) { oprot.writeFieldBegin(MUTATIONS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.mutations.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.mutations.size())); for (Mutation _iter113 : this.mutations) { _iter113.write(oprot); @@ -24706,41 +23959,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class mutateRowTs_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("mutateRowTs_result"); - } - - public static class mutateRowTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("mutateRowTs_result"); - - 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.protocol.TField IA_FIELD_DESC = new org.apache.thrift.protocol.TField("ia", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); + private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2); public IOError io; public IllegalArgument ia; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { IO((short)1, "io"), IA((short)2, "ia"); @@ -24802,15 +24037,15 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); - tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); + tmpMap.put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRowTs_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(mutateRowTs_result.class, metaDataMap); } public mutateRowTs_result() { @@ -24860,7 +24095,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -24884,7 +24119,7 @@ public class Hbase { this.ia = null; } - /** Returns true if field ia is set (has been assigned a value) and false otherwise */ + /** Returns true if field ia is set (has been asigned a value) and false otherwise */ public boolean isSetIa() { return this.ia != null; } @@ -24928,7 +24163,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -24995,7 +24230,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -25005,7 +24240,7 @@ public class Hbase { return lastComparison; } if (isSetIa()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, typedOther.ia); + lastComparison = TBaseHelper.compareTo(this.ia, typedOther.ia); if (lastComparison != 0) { return lastComparison; } @@ -25017,34 +24252,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // IA - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.ia = new IllegalArgument(); this.ia.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -25054,7 +24289,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetIo()) { @@ -25094,33 +24329,17 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class mutateRows_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("mutateRows_args"); - } - - public static class mutateRows_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("mutateRows_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROW_BATCHES_FIELD_DESC = new org.apache.thrift.protocol.TField("rowBatches", org.apache.thrift.protocol.TType.LIST, (short)2); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROW_BATCHES_FIELD_DESC = new TField("rowBatches", TType.LIST, (short)2); /** * name of table @@ -25132,7 +24351,7 @@ public class Hbase { public List rowBatches; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -25200,16 +24419,16 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROW_BATCHES, new org.apache.thrift.meta_data.FieldMetaData("rowBatches", 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, BatchMutation.class)))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW_BATCHES, new FieldMetaData("rowBatches", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, BatchMutation.class)))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRows_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(mutateRows_args.class, metaDataMap); } public mutateRows_args() { @@ -25254,11 +24473,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -25266,7 +24485,7 @@ public class Hbase { * name of table */ public mutateRows_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -25279,7 +24498,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -25324,7 +24543,7 @@ public class Hbase { this.rowBatches = null; } - /** Returns true if field rowBatches is set (has been assigned a value) and false otherwise */ + /** Returns true if field rowBatches is set (has been asigned a value) and false otherwise */ public boolean isSetRowBatches() { return this.rowBatches != null; } @@ -25368,7 +24587,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -25435,7 +24654,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -25445,7 +24664,7 @@ public class Hbase { return lastComparison; } if (isSetRowBatches()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rowBatches, typedOther.rowBatches); + lastComparison = TBaseHelper.compareTo(this.rowBatches, typedOther.rowBatches); if (lastComparison != 0) { return lastComparison; } @@ -25457,27 +24676,27 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROW_BATCHES - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list114 = iprot.readListBegin(); + TList _list114 = iprot.readListBegin(); this.rowBatches = new ArrayList(_list114.size); for (int _i115 = 0; _i115 < _list114.size; ++_i115) { @@ -25489,11 +24708,11 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -25503,7 +24722,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -25515,7 +24734,7 @@ public class Hbase { if (this.rowBatches != null) { oprot.writeFieldBegin(ROW_BATCHES_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.rowBatches.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.rowBatches.size())); for (BatchMutation _iter117 : this.rowBatches) { _iter117.write(oprot); @@ -25552,39 +24771,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class mutateRows_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("mutateRows_result"); - } - - public static class mutateRows_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("mutateRows_result"); - - 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.protocol.TField IA_FIELD_DESC = new org.apache.thrift.protocol.TField("ia", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); + private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2); public IOError io; public IllegalArgument ia; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { IO((short)1, "io"), IA((short)2, "ia"); @@ -25646,15 +24849,15 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); - tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); + tmpMap.put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRows_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(mutateRows_result.class, metaDataMap); } public mutateRows_result() { @@ -25704,7 +24907,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -25728,7 +24931,7 @@ public class Hbase { this.ia = null; } - /** Returns true if field ia is set (has been assigned a value) and false otherwise */ + /** Returns true if field ia is set (has been asigned a value) and false otherwise */ public boolean isSetIa() { return this.ia != null; } @@ -25772,7 +24975,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -25839,7 +25042,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -25849,7 +25052,7 @@ public class Hbase { return lastComparison; } if (isSetIa()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, typedOther.ia); + lastComparison = TBaseHelper.compareTo(this.ia, typedOther.ia); if (lastComparison != 0) { return lastComparison; } @@ -25861,34 +25064,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // IA - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.ia = new IllegalArgument(); this.ia.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -25898,7 +25101,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetIo()) { @@ -25938,34 +25141,18 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class mutateRowsTs_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("mutateRowsTs_args"); - } - - public static class mutateRowsTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("mutateRowsTs_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROW_BATCHES_FIELD_DESC = new org.apache.thrift.protocol.TField("rowBatches", org.apache.thrift.protocol.TType.LIST, (short)2); - private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)3); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROW_BATCHES_FIELD_DESC = new TField("rowBatches", TType.LIST, (short)2); + private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3); /** * name of table @@ -25981,7 +25168,7 @@ public class Hbase { public long timestamp; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -26057,18 +25244,18 @@ public class Hbase { private static final int __TIMESTAMP_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROW_BATCHES, new org.apache.thrift.meta_data.FieldMetaData("rowBatches", 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, BatchMutation.class)))); - tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW_BATCHES, new FieldMetaData("rowBatches", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, BatchMutation.class)))); + tmpMap.put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I64))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRowsTs_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(mutateRowsTs_args.class, metaDataMap); } public mutateRowsTs_args() { @@ -26121,11 +25308,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -26133,7 +25320,7 @@ public class Hbase { * name of table */ public mutateRowsTs_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -26146,7 +25333,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -26191,7 +25378,7 @@ public class Hbase { this.rowBatches = null; } - /** Returns true if field rowBatches is set (has been assigned a value) and false otherwise */ + /** Returns true if field rowBatches is set (has been asigned a value) and false otherwise */ public boolean isSetRowBatches() { return this.rowBatches != null; } @@ -26222,7 +25409,7 @@ public class Hbase { __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); } - /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ + /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */ public boolean isSetTimestamp() { return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); } @@ -26275,7 +25462,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -26353,7 +25540,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -26363,7 +25550,7 @@ public class Hbase { return lastComparison; } if (isSetRowBatches()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rowBatches, typedOther.rowBatches); + lastComparison = TBaseHelper.compareTo(this.rowBatches, typedOther.rowBatches); if (lastComparison != 0) { return lastComparison; } @@ -26373,7 +25560,7 @@ public class Hbase { return lastComparison; } if (isSetTimestamp()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + lastComparison = TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); if (lastComparison != 0) { return lastComparison; } @@ -26385,27 +25572,27 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROW_BATCHES - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list118 = iprot.readListBegin(); + TList _list118 = iprot.readListBegin(); this.rowBatches = new ArrayList(_list118.size); for (int _i119 = 0; _i119 < _list118.size; ++_i119) { @@ -26417,19 +25604,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // TIMESTAMP - if (field.type == org.apache.thrift.protocol.TType.I64) { + if (field.type == TType.I64) { this.timestamp = iprot.readI64(); setTimestampIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -26439,7 +25626,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -26451,7 +25638,7 @@ public class Hbase { if (this.rowBatches != null) { oprot.writeFieldBegin(ROW_BATCHES_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.rowBatches.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.rowBatches.size())); for (BatchMutation _iter121 : this.rowBatches) { _iter121.write(oprot); @@ -26495,39 +25682,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class mutateRowsTs_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("mutateRowsTs_result"); - } - - public static class mutateRowsTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("mutateRowsTs_result"); - - 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.protocol.TField IA_FIELD_DESC = new org.apache.thrift.protocol.TField("ia", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); + private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2); public IOError io; public IllegalArgument ia; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { IO((short)1, "io"), IA((short)2, "ia"); @@ -26589,15 +25760,15 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); - tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); + tmpMap.put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRowsTs_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(mutateRowsTs_result.class, metaDataMap); } public mutateRowsTs_result() { @@ -26647,7 +25818,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -26671,7 +25842,7 @@ public class Hbase { this.ia = null; } - /** Returns true if field ia is set (has been assigned a value) and false otherwise */ + /** Returns true if field ia is set (has been asigned a value) and false otherwise */ public boolean isSetIa() { return this.ia != null; } @@ -26715,7 +25886,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -26782,7 +25953,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -26792,7 +25963,7 @@ public class Hbase { return lastComparison; } if (isSetIa()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, typedOther.ia); + lastComparison = TBaseHelper.compareTo(this.ia, typedOther.ia); if (lastComparison != 0) { return lastComparison; } @@ -26804,34 +25975,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // IA - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.ia = new IllegalArgument(); this.ia.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -26841,7 +26012,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetIo()) { @@ -26881,35 +26052,19 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class atomicIncrement_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("atomicIncrement_args"); - } - - public static class atomicIncrement_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("atomicIncrement_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField COLUMN_FIELD_DESC = new org.apache.thrift.protocol.TField("column", org.apache.thrift.protocol.TType.STRING, (short)3); - private static final org.apache.thrift.protocol.TField VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("value", org.apache.thrift.protocol.TType.I64, (short)4); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2); + private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3); + private static final TField VALUE_FIELD_DESC = new TField("value", TType.I64, (short)4); /** * name of table @@ -26929,7 +26084,7 @@ public class Hbase { public long value; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -27011,19 +26166,19 @@ public class Hbase { private static final int __VALUE_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.COLUMN, new org.apache.thrift.meta_data.FieldMetaData("column", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.VALUE, new org.apache.thrift.meta_data.FieldMetaData("value", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.VALUE, new FieldMetaData("value", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I64))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(atomicIncrement_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(atomicIncrement_args.class, metaDataMap); } public atomicIncrement_args() { @@ -27078,11 +26233,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -27090,7 +26245,7 @@ public class Hbase { * name of table */ public atomicIncrement_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -27103,7 +26258,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -27118,11 +26273,11 @@ public class Hbase { * row to increment */ public byte[] getRow() { - setRow(org.apache.thrift.TBaseHelper.rightSize(row)); - return row == null ? null : row.array(); + setRow(TBaseHelper.rightSize(row)); + return row.array(); } - public ByteBuffer bufferForRow() { + public ByteBuffer BufferForRow() { return row; } @@ -27130,7 +26285,7 @@ public class Hbase { * row to increment */ public atomicIncrement_args setRow(byte[] row) { - setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + setRow(ByteBuffer.wrap(row)); return this; } @@ -27143,7 +26298,7 @@ public class Hbase { this.row = null; } - /** Returns true if field row is set (has been assigned a value) and false otherwise */ + /** Returns true if field row is set (has been asigned a value) and false otherwise */ public boolean isSetRow() { return this.row != null; } @@ -27158,11 +26313,11 @@ public class Hbase { * name of column */ public byte[] getColumn() { - setColumn(org.apache.thrift.TBaseHelper.rightSize(column)); - return column == null ? null : column.array(); + setColumn(TBaseHelper.rightSize(column)); + return column.array(); } - public ByteBuffer bufferForColumn() { + public ByteBuffer BufferForColumn() { return column; } @@ -27170,7 +26325,7 @@ public class Hbase { * name of column */ public atomicIncrement_args setColumn(byte[] column) { - setColumn(column == null ? (ByteBuffer)null : ByteBuffer.wrap(column)); + setColumn(ByteBuffer.wrap(column)); return this; } @@ -27183,7 +26338,7 @@ public class Hbase { this.column = null; } - /** Returns true if field column is set (has been assigned a value) and false otherwise */ + /** Returns true if field column is set (has been asigned a value) and false otherwise */ public boolean isSetColumn() { return this.column != null; } @@ -27214,7 +26369,7 @@ public class Hbase { __isset_bit_vector.clear(__VALUE_ISSET_ID); } - /** Returns true if field value is set (has been assigned a value) and false otherwise */ + /** Returns true if field value is set (has been asigned a value) and false otherwise */ public boolean isSetValue() { return __isset_bit_vector.get(__VALUE_ISSET_ID); } @@ -27278,7 +26433,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -27367,7 +26522,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -27377,7 +26532,7 @@ public class Hbase { return lastComparison; } if (isSetRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + lastComparison = TBaseHelper.compareTo(this.row, typedOther.row); if (lastComparison != 0) { return lastComparison; } @@ -27387,7 +26542,7 @@ public class Hbase { return lastComparison; } if (isSetColumn()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, typedOther.column); + lastComparison = TBaseHelper.compareTo(this.column, typedOther.column); if (lastComparison != 0) { return lastComparison; } @@ -27397,7 +26552,7 @@ public class Hbase { return lastComparison; } if (isSetValue()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, typedOther.value); + lastComparison = TBaseHelper.compareTo(this.value, typedOther.value); if (lastComparison != 0) { return lastComparison; } @@ -27409,47 +26564,47 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.row = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // COLUMN - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.column = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 4: // VALUE - if (field.type == org.apache.thrift.protocol.TType.I64) { + if (field.type == TType.I64) { this.value = iprot.readI64(); setValueIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -27459,7 +26614,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -27521,43 +26676,25 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class atomicIncrement_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("atomicIncrement_result"); - } - - public static class atomicIncrement_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("atomicIncrement_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.I64, (short)0); - private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); - private static final org.apache.thrift.protocol.TField IA_FIELD_DESC = new org.apache.thrift.protocol.TField("ia", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I64, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); + private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2); public long success; public IOError io; public IllegalArgument ia; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"), IA((short)2, "ia"); @@ -27624,17 +26761,17 @@ public class Hbase { private static final int __SUCCESS_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); - tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I64))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); + tmpMap.put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(atomicIncrement_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(atomicIncrement_result.class, metaDataMap); } public atomicIncrement_result() { @@ -27693,7 +26830,7 @@ public class Hbase { __isset_bit_vector.clear(__SUCCESS_ISSET_ID); } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return __isset_bit_vector.get(__SUCCESS_ISSET_ID); } @@ -27715,7 +26852,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -27739,7 +26876,7 @@ public class Hbase { this.ia = null; } - /** Returns true if field ia is set (has been assigned a value) and false otherwise */ + /** Returns true if field ia is set (has been asigned a value) and false otherwise */ public boolean isSetIa() { return this.ia != null; } @@ -27794,7 +26931,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -27872,7 +27009,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -27882,7 +27019,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -27892,7 +27029,7 @@ public class Hbase { return lastComparison; } if (isSetIa()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, typedOther.ia); + lastComparison = TBaseHelper.compareTo(this.ia, typedOther.ia); if (lastComparison != 0) { return lastComparison; } @@ -27904,42 +27041,42 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.I64) { + if (field.type == TType.I64) { this.success = iprot.readI64(); setSuccessIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // IA - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.ia = new IllegalArgument(); this.ia.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -27949,7 +27086,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { @@ -27997,34 +27134,18 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class deleteAll_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("deleteAll_args"); - } - - public static class deleteAll_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteAll_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField COLUMN_FIELD_DESC = new org.apache.thrift.protocol.TField("column", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2); + private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3); /** * name of table @@ -28040,7 +27161,7 @@ public class Hbase { public ByteBuffer column; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -28114,17 +27235,17 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.COLUMN, new org.apache.thrift.meta_data.FieldMetaData("column", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteAll_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(deleteAll_args.class, metaDataMap); } public deleteAll_args() { @@ -28171,11 +27292,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -28183,7 +27304,7 @@ public class Hbase { * name of table */ public deleteAll_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -28196,7 +27317,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -28211,11 +27332,11 @@ public class Hbase { * Row to update */ public byte[] getRow() { - setRow(org.apache.thrift.TBaseHelper.rightSize(row)); - return row == null ? null : row.array(); + setRow(TBaseHelper.rightSize(row)); + return row.array(); } - public ByteBuffer bufferForRow() { + public ByteBuffer BufferForRow() { return row; } @@ -28223,7 +27344,7 @@ public class Hbase { * Row to update */ public deleteAll_args setRow(byte[] row) { - setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + setRow(ByteBuffer.wrap(row)); return this; } @@ -28236,7 +27357,7 @@ public class Hbase { this.row = null; } - /** Returns true if field row is set (has been assigned a value) and false otherwise */ + /** Returns true if field row is set (has been asigned a value) and false otherwise */ public boolean isSetRow() { return this.row != null; } @@ -28251,11 +27372,11 @@ public class Hbase { * name of column whose value is to be deleted */ public byte[] getColumn() { - setColumn(org.apache.thrift.TBaseHelper.rightSize(column)); - return column == null ? null : column.array(); + setColumn(TBaseHelper.rightSize(column)); + return column.array(); } - public ByteBuffer bufferForColumn() { + public ByteBuffer BufferForColumn() { return column; } @@ -28263,7 +27384,7 @@ public class Hbase { * name of column whose value is to be deleted */ public deleteAll_args setColumn(byte[] column) { - setColumn(column == null ? (ByteBuffer)null : ByteBuffer.wrap(column)); + setColumn(ByteBuffer.wrap(column)); return this; } @@ -28276,7 +27397,7 @@ public class Hbase { this.column = null; } - /** Returns true if field column is set (has been assigned a value) and false otherwise */ + /** Returns true if field column is set (has been asigned a value) and false otherwise */ public boolean isSetColumn() { return this.column != null; } @@ -28331,7 +27452,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -28409,7 +27530,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -28419,7 +27540,7 @@ public class Hbase { return lastComparison; } if (isSetRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + lastComparison = TBaseHelper.compareTo(this.row, typedOther.row); if (lastComparison != 0) { return lastComparison; } @@ -28429,7 +27550,7 @@ public class Hbase { return lastComparison; } if (isSetColumn()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, typedOther.column); + lastComparison = TBaseHelper.compareTo(this.column, typedOther.column); if (lastComparison != 0) { return lastComparison; } @@ -28441,39 +27562,39 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.row = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // COLUMN - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.column = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -28483,7 +27604,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -28538,37 +27659,21 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class deleteAll_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("deleteAll_result"); - } - - public static class deleteAll_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteAll_result"); - - 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 TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { IO((short)1, "io"); private static final Map byName = new HashMap(); @@ -28627,13 +27732,13 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteAll_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(deleteAll_result.class, metaDataMap); } public deleteAll_result() { @@ -28677,7 +27782,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -28710,7 +27815,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -28766,7 +27871,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -28778,26 +27883,26 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -28807,7 +27912,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetIo()) { @@ -28835,35 +27940,19 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class deleteAllTs_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("deleteAllTs_args"); - } - - public static class deleteAllTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteAllTs_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField COLUMN_FIELD_DESC = new org.apache.thrift.protocol.TField("column", org.apache.thrift.protocol.TType.STRING, (short)3); - private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)4); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2); + private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3); + private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4); /** * name of table @@ -28883,7 +27972,7 @@ public class Hbase { public long timestamp; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -28965,19 +28054,19 @@ public class Hbase { private static final int __TIMESTAMP_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.COLUMN, new org.apache.thrift.meta_data.FieldMetaData("column", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I64))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteAllTs_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(deleteAllTs_args.class, metaDataMap); } public deleteAllTs_args() { @@ -29032,11 +28121,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -29044,7 +28133,7 @@ public class Hbase { * name of table */ public deleteAllTs_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -29057,7 +28146,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -29072,11 +28161,11 @@ public class Hbase { * Row to update */ public byte[] getRow() { - setRow(org.apache.thrift.TBaseHelper.rightSize(row)); - return row == null ? null : row.array(); + setRow(TBaseHelper.rightSize(row)); + return row.array(); } - public ByteBuffer bufferForRow() { + public ByteBuffer BufferForRow() { return row; } @@ -29084,7 +28173,7 @@ public class Hbase { * Row to update */ public deleteAllTs_args setRow(byte[] row) { - setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + setRow(ByteBuffer.wrap(row)); return this; } @@ -29097,7 +28186,7 @@ public class Hbase { this.row = null; } - /** Returns true if field row is set (has been assigned a value) and false otherwise */ + /** Returns true if field row is set (has been asigned a value) and false otherwise */ public boolean isSetRow() { return this.row != null; } @@ -29112,11 +28201,11 @@ public class Hbase { * name of column whose value is to be deleted */ public byte[] getColumn() { - setColumn(org.apache.thrift.TBaseHelper.rightSize(column)); - return column == null ? null : column.array(); + setColumn(TBaseHelper.rightSize(column)); + return column.array(); } - public ByteBuffer bufferForColumn() { + public ByteBuffer BufferForColumn() { return column; } @@ -29124,7 +28213,7 @@ public class Hbase { * name of column whose value is to be deleted */ public deleteAllTs_args setColumn(byte[] column) { - setColumn(column == null ? (ByteBuffer)null : ByteBuffer.wrap(column)); + setColumn(ByteBuffer.wrap(column)); return this; } @@ -29137,7 +28226,7 @@ public class Hbase { this.column = null; } - /** Returns true if field column is set (has been assigned a value) and false otherwise */ + /** Returns true if field column is set (has been asigned a value) and false otherwise */ public boolean isSetColumn() { return this.column != null; } @@ -29168,7 +28257,7 @@ public class Hbase { __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); } - /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ + /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */ public boolean isSetTimestamp() { return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); } @@ -29232,7 +28321,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -29321,7 +28410,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -29331,7 +28420,7 @@ public class Hbase { return lastComparison; } if (isSetRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + lastComparison = TBaseHelper.compareTo(this.row, typedOther.row); if (lastComparison != 0) { return lastComparison; } @@ -29341,7 +28430,7 @@ public class Hbase { return lastComparison; } if (isSetColumn()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, typedOther.column); + lastComparison = TBaseHelper.compareTo(this.column, typedOther.column); if (lastComparison != 0) { return lastComparison; } @@ -29351,7 +28440,7 @@ public class Hbase { return lastComparison; } if (isSetTimestamp()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + lastComparison = TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); if (lastComparison != 0) { return lastComparison; } @@ -29363,47 +28452,47 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.row = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // COLUMN - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.column = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 4: // TIMESTAMP - if (field.type == org.apache.thrift.protocol.TType.I64) { + if (field.type == TType.I64) { this.timestamp = iprot.readI64(); setTimestampIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -29413,7 +28502,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -29475,39 +28564,21 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class deleteAllTs_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("deleteAllTs_result"); - } - - public static class deleteAllTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteAllTs_result"); - - 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 TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { IO((short)1, "io"); private static final Map byName = new HashMap(); @@ -29566,13 +28637,13 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteAllTs_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(deleteAllTs_result.class, metaDataMap); } public deleteAllTs_result() { @@ -29616,7 +28687,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -29649,7 +28720,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -29705,7 +28776,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -29717,26 +28788,26 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -29746,7 +28817,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetIo()) { @@ -29774,33 +28845,17 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class deleteAllRow_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("deleteAllRow_args"); - } - - public static class deleteAllRow_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteAllRow_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2); /** * name of table @@ -29812,7 +28867,7 @@ public class Hbase { public ByteBuffer row; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -29880,15 +28935,15 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteAllRow_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(deleteAllRow_args.class, metaDataMap); } public deleteAllRow_args() { @@ -29929,11 +28984,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -29941,7 +28996,7 @@ public class Hbase { * name of table */ public deleteAllRow_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -29954,7 +29009,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -29969,11 +29024,11 @@ public class Hbase { * key of the row to be completely deleted. */ public byte[] getRow() { - setRow(org.apache.thrift.TBaseHelper.rightSize(row)); - return row == null ? null : row.array(); + setRow(TBaseHelper.rightSize(row)); + return row.array(); } - public ByteBuffer bufferForRow() { + public ByteBuffer BufferForRow() { return row; } @@ -29981,7 +29036,7 @@ public class Hbase { * key of the row to be completely deleted. */ public deleteAllRow_args setRow(byte[] row) { - setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + setRow(ByteBuffer.wrap(row)); return this; } @@ -29994,7 +29049,7 @@ public class Hbase { this.row = null; } - /** Returns true if field row is set (has been assigned a value) and false otherwise */ + /** Returns true if field row is set (has been asigned a value) and false otherwise */ public boolean isSetRow() { return this.row != null; } @@ -30038,7 +29093,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -30105,7 +29160,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -30115,7 +29170,7 @@ public class Hbase { return lastComparison; } if (isSetRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + lastComparison = TBaseHelper.compareTo(this.row, typedOther.row); if (lastComparison != 0) { return lastComparison; } @@ -30127,32 +29182,32 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.row = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -30162,7 +29217,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -30204,37 +29259,21 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class deleteAllRow_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("deleteAllRow_result"); - } - - public static class deleteAllRow_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteAllRow_result"); - - 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 TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { IO((short)1, "io"); private static final Map byName = new HashMap(); @@ -30293,13 +29332,13 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteAllRow_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(deleteAllRow_result.class, metaDataMap); } public deleteAllRow_result() { @@ -30343,7 +29382,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -30376,7 +29415,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -30432,7 +29471,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -30444,26 +29483,26 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -30473,7 +29512,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetIo()) { @@ -30501,34 +29540,18 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class deleteAllRowTs_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("deleteAllRowTs_args"); - } - - public static class deleteAllRowTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteAllRowTs_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)3); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2); + private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3); /** * name of table @@ -30544,7 +29567,7 @@ public class Hbase { public long timestamp; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -30620,17 +29643,17 @@ public class Hbase { private static final int __TIMESTAMP_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I64))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteAllRowTs_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(deleteAllRowTs_args.class, metaDataMap); } public deleteAllRowTs_args() { @@ -30679,11 +29702,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -30691,7 +29714,7 @@ public class Hbase { * name of table */ public deleteAllRowTs_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -30704,7 +29727,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -30719,11 +29742,11 @@ public class Hbase { * key of the row to be completely deleted. */ public byte[] getRow() { - setRow(org.apache.thrift.TBaseHelper.rightSize(row)); - return row == null ? null : row.array(); + setRow(TBaseHelper.rightSize(row)); + return row.array(); } - public ByteBuffer bufferForRow() { + public ByteBuffer BufferForRow() { return row; } @@ -30731,7 +29754,7 @@ public class Hbase { * key of the row to be completely deleted. */ public deleteAllRowTs_args setRow(byte[] row) { - setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + setRow(ByteBuffer.wrap(row)); return this; } @@ -30744,7 +29767,7 @@ public class Hbase { this.row = null; } - /** Returns true if field row is set (has been assigned a value) and false otherwise */ + /** Returns true if field row is set (has been asigned a value) and false otherwise */ public boolean isSetRow() { return this.row != null; } @@ -30775,7 +29798,7 @@ public class Hbase { __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); } - /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ + /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */ public boolean isSetTimestamp() { return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); } @@ -30828,7 +29851,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -30906,7 +29929,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -30916,7 +29939,7 @@ public class Hbase { return lastComparison; } if (isSetRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + lastComparison = TBaseHelper.compareTo(this.row, typedOther.row); if (lastComparison != 0) { return lastComparison; } @@ -30926,7 +29949,7 @@ public class Hbase { return lastComparison; } if (isSetTimestamp()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + lastComparison = TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); if (lastComparison != 0) { return lastComparison; } @@ -30938,40 +29961,40 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.row = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // TIMESTAMP - if (field.type == org.apache.thrift.protocol.TType.I64) { + if (field.type == TType.I64) { this.timestamp = iprot.readI64(); setTimestampIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -30981,7 +30004,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -31030,39 +30053,21 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class deleteAllRowTs_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("deleteAllRowTs_result"); - } - - public static class deleteAllRowTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteAllRowTs_result"); - - 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 TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { IO((short)1, "io"); private static final Map byName = new HashMap(); @@ -31121,13 +30126,13 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteAllRowTs_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(deleteAllRowTs_result.class, metaDataMap); } public deleteAllRowTs_result() { @@ -31171,7 +30176,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -31204,7 +30209,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -31260,7 +30265,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -31272,26 +30277,26 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -31301,7 +30306,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetIo()) { @@ -31329,33 +30334,17 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class scannerOpenWithScan_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithScan_args"); - } - - public static class scannerOpenWithScan_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("scannerOpenWithScan_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField SCAN_FIELD_DESC = new org.apache.thrift.protocol.TField("scan", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField SCAN_FIELD_DESC = new TField("scan", TType.STRUCT, (short)2); /** * name of table @@ -31367,7 +30356,7 @@ public class Hbase { public TScan scan; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -31435,15 +30424,15 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.SCAN, new org.apache.thrift.meta_data.FieldMetaData("scan", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TScan.class))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.SCAN, new FieldMetaData("scan", TFieldRequirementType.DEFAULT, + new StructMetaData(TType.STRUCT, TScan.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenWithScan_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(scannerOpenWithScan_args.class, metaDataMap); } public scannerOpenWithScan_args() { @@ -31484,11 +30473,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -31496,7 +30485,7 @@ public class Hbase { * name of table */ public scannerOpenWithScan_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -31509,7 +30498,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -31539,7 +30528,7 @@ public class Hbase { this.scan = null; } - /** Returns true if field scan is set (has been assigned a value) and false otherwise */ + /** Returns true if field scan is set (has been asigned a value) and false otherwise */ public boolean isSetScan() { return this.scan != null; } @@ -31583,7 +30572,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -31650,7 +30639,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -31660,7 +30649,7 @@ public class Hbase { return lastComparison; } if (isSetScan()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scan, typedOther.scan); + lastComparison = TBaseHelper.compareTo(this.scan, typedOther.scan); if (lastComparison != 0) { return lastComparison; } @@ -31672,33 +30661,33 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // SCAN - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.scan = new TScan(); this.scan.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -31708,7 +30697,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -31750,39 +30739,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class scannerOpenWithScan_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithScan_result"); - } - - public static class scannerOpenWithScan_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("scannerOpenWithScan_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.I32, (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 TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public int success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -31846,15 +30819,15 @@ public class Hbase { private static final int __SUCCESS_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "ScannerID"))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I32 , "ScannerID"))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenWithScan_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(scannerOpenWithScan_result.class, metaDataMap); } public scannerOpenWithScan_result() { @@ -31907,7 +30880,7 @@ public class Hbase { __isset_bit_vector.clear(__SUCCESS_ISSET_ID); } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return __isset_bit_vector.get(__SUCCESS_ISSET_ID); } @@ -31929,7 +30902,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -31973,7 +30946,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -32040,7 +31013,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -32050,7 +31023,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -32062,34 +31035,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.I32) { + if (field.type == TType.I32) { this.success = iprot.readI32(); setSuccessIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -32099,7 +31072,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { @@ -32135,34 +31108,18 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class scannerOpen_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("scannerOpen_args"); - } - - public static class scannerOpen_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("scannerOpen_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField START_ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("startRow", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)3); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2); + private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3); /** * name of table @@ -32181,7 +31138,7 @@ public class Hbase { public List columns; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -32258,18 +31215,18 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.START_ROW, new org.apache.thrift.meta_data.FieldMetaData("startRow", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new FieldValueMetaData(TType.STRING , "Text")))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpen_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(scannerOpen_args.class, metaDataMap); } public scannerOpen_args() { @@ -32320,11 +31277,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -32332,7 +31289,7 @@ public class Hbase { * name of table */ public scannerOpen_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -32345,7 +31302,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -32361,11 +31318,11 @@ public class Hbase { * Send "" (empty string) to start at the first row. */ public byte[] getStartRow() { - setStartRow(org.apache.thrift.TBaseHelper.rightSize(startRow)); - return startRow == null ? null : startRow.array(); + setStartRow(TBaseHelper.rightSize(startRow)); + return startRow.array(); } - public ByteBuffer bufferForStartRow() { + public ByteBuffer BufferForStartRow() { return startRow; } @@ -32374,7 +31331,7 @@ public class Hbase { * Send "" (empty string) to start at the first row. */ public scannerOpen_args setStartRow(byte[] startRow) { - setStartRow(startRow == null ? (ByteBuffer)null : ByteBuffer.wrap(startRow)); + setStartRow(ByteBuffer.wrap(startRow)); return this; } @@ -32387,7 +31344,7 @@ public class Hbase { this.startRow = null; } - /** Returns true if field startRow is set (has been assigned a value) and false otherwise */ + /** Returns true if field startRow is set (has been asigned a value) and false otherwise */ public boolean isSetStartRow() { return this.startRow != null; } @@ -32436,7 +31393,7 @@ public class Hbase { this.columns = null; } - /** Returns true if field columns is set (has been assigned a value) and false otherwise */ + /** Returns true if field columns is set (has been asigned a value) and false otherwise */ public boolean isSetColumns() { return this.columns != null; } @@ -32491,7 +31448,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -32569,7 +31526,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -32579,7 +31536,7 @@ public class Hbase { return lastComparison; } if (isSetStartRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startRow, typedOther.startRow); + lastComparison = TBaseHelper.compareTo(this.startRow, typedOther.startRow); if (lastComparison != 0) { return lastComparison; } @@ -32589,7 +31546,7 @@ public class Hbase { return lastComparison; } if (isSetColumns()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns); + lastComparison = TBaseHelper.compareTo(this.columns, typedOther.columns); if (lastComparison != 0) { return lastComparison; } @@ -32601,34 +31558,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // START_ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.startRow = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // COLUMNS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list122 = iprot.readListBegin(); + TList _list122 = iprot.readListBegin(); this.columns = new ArrayList(_list122.size); for (int _i123 = 0; _i123 < _list122.size; ++_i123) { @@ -32639,11 +31596,11 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -32653,7 +31610,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -32670,7 +31627,7 @@ public class Hbase { if (this.columns != null) { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); + oprot.writeListBegin(new TList(TType.STRING, this.columns.size())); for (ByteBuffer _iter125 : this.columns) { oprot.writeBinary(_iter125); @@ -32715,39 +31672,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class scannerOpen_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("scannerOpen_result"); - } - - public static class scannerOpen_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("scannerOpen_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.I32, (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 TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public int success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -32811,15 +31752,15 @@ public class Hbase { private static final int __SUCCESS_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "ScannerID"))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I32 , "ScannerID"))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpen_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(scannerOpen_result.class, metaDataMap); } public scannerOpen_result() { @@ -32872,7 +31813,7 @@ public class Hbase { __isset_bit_vector.clear(__SUCCESS_ISSET_ID); } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return __isset_bit_vector.get(__SUCCESS_ISSET_ID); } @@ -32894,7 +31835,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -32938,7 +31879,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -33005,7 +31946,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -33015,7 +31956,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -33027,34 +31968,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.I32) { + if (field.type == TType.I32) { this.success = iprot.readI32(); setSuccessIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -33064,7 +32005,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { @@ -33100,35 +32041,19 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class scannerOpenWithStop_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStop_args"); - } - - public static class scannerOpenWithStop_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("scannerOpenWithStop_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField START_ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("startRow", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField STOP_ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("stopRow", org.apache.thrift.protocol.TType.STRING, (short)3); - private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)4); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2); + private static final TField STOP_ROW_FIELD_DESC = new TField("stopRow", TType.STRING, (short)3); + private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)4); /** * name of table @@ -33152,7 +32077,7 @@ public class Hbase { public List columns; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -33236,20 +32161,20 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.START_ROW, new org.apache.thrift.meta_data.FieldMetaData("startRow", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.STOP_ROW, new org.apache.thrift.meta_data.FieldMetaData("stopRow", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.STOP_ROW, new FieldMetaData("stopRow", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new FieldValueMetaData(TType.STRING , "Text")))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenWithStop_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(scannerOpenWithStop_args.class, metaDataMap); } public scannerOpenWithStop_args() { @@ -33306,11 +32231,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -33318,7 +32243,7 @@ public class Hbase { * name of table */ public scannerOpenWithStop_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -33331,7 +32256,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -33347,11 +32272,11 @@ public class Hbase { * Send "" (empty string) to start at the first row. */ public byte[] getStartRow() { - setStartRow(org.apache.thrift.TBaseHelper.rightSize(startRow)); - return startRow == null ? null : startRow.array(); + setStartRow(TBaseHelper.rightSize(startRow)); + return startRow.array(); } - public ByteBuffer bufferForStartRow() { + public ByteBuffer BufferForStartRow() { return startRow; } @@ -33360,7 +32285,7 @@ public class Hbase { * Send "" (empty string) to start at the first row. */ public scannerOpenWithStop_args setStartRow(byte[] startRow) { - setStartRow(startRow == null ? (ByteBuffer)null : ByteBuffer.wrap(startRow)); + setStartRow(ByteBuffer.wrap(startRow)); return this; } @@ -33373,7 +32298,7 @@ public class Hbase { this.startRow = null; } - /** Returns true if field startRow is set (has been assigned a value) and false otherwise */ + /** Returns true if field startRow is set (has been asigned a value) and false otherwise */ public boolean isSetStartRow() { return this.startRow != null; } @@ -33389,11 +32314,11 @@ public class Hbase { * scanner's results */ public byte[] getStopRow() { - setStopRow(org.apache.thrift.TBaseHelper.rightSize(stopRow)); - return stopRow == null ? null : stopRow.array(); + setStopRow(TBaseHelper.rightSize(stopRow)); + return stopRow.array(); } - public ByteBuffer bufferForStopRow() { + public ByteBuffer BufferForStopRow() { return stopRow; } @@ -33402,7 +32327,7 @@ public class Hbase { * scanner's results */ public scannerOpenWithStop_args setStopRow(byte[] stopRow) { - setStopRow(stopRow == null ? (ByteBuffer)null : ByteBuffer.wrap(stopRow)); + setStopRow(ByteBuffer.wrap(stopRow)); return this; } @@ -33415,7 +32340,7 @@ public class Hbase { this.stopRow = null; } - /** Returns true if field stopRow is set (has been assigned a value) and false otherwise */ + /** Returns true if field stopRow is set (has been asigned a value) and false otherwise */ public boolean isSetStopRow() { return this.stopRow != null; } @@ -33464,7 +32389,7 @@ public class Hbase { this.columns = null; } - /** Returns true if field columns is set (has been assigned a value) and false otherwise */ + /** Returns true if field columns is set (has been asigned a value) and false otherwise */ public boolean isSetColumns() { return this.columns != null; } @@ -33530,7 +32455,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -33619,7 +32544,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -33629,7 +32554,7 @@ public class Hbase { return lastComparison; } if (isSetStartRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startRow, typedOther.startRow); + lastComparison = TBaseHelper.compareTo(this.startRow, typedOther.startRow); if (lastComparison != 0) { return lastComparison; } @@ -33639,7 +32564,7 @@ public class Hbase { return lastComparison; } if (isSetStopRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.stopRow, typedOther.stopRow); + lastComparison = TBaseHelper.compareTo(this.stopRow, typedOther.stopRow); if (lastComparison != 0) { return lastComparison; } @@ -33649,7 +32574,7 @@ public class Hbase { return lastComparison; } if (isSetColumns()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns); + lastComparison = TBaseHelper.compareTo(this.columns, typedOther.columns); if (lastComparison != 0) { return lastComparison; } @@ -33661,41 +32586,41 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // START_ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.startRow = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // STOP_ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.stopRow = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 4: // COLUMNS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list126 = iprot.readListBegin(); + TList _list126 = iprot.readListBegin(); this.columns = new ArrayList(_list126.size); for (int _i127 = 0; _i127 < _list126.size; ++_i127) { @@ -33706,11 +32631,11 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -33720,7 +32645,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -33742,7 +32667,7 @@ public class Hbase { if (this.columns != null) { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); + oprot.writeListBegin(new TList(TType.STRING, this.columns.size())); for (ByteBuffer _iter129 : this.columns) { oprot.writeBinary(_iter129); @@ -33795,39 +32720,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class scannerOpenWithStop_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStop_result"); - } - - public static class scannerOpenWithStop_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("scannerOpenWithStop_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.I32, (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 TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public int success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -33891,15 +32800,15 @@ public class Hbase { private static final int __SUCCESS_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "ScannerID"))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I32 , "ScannerID"))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenWithStop_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(scannerOpenWithStop_result.class, metaDataMap); } public scannerOpenWithStop_result() { @@ -33952,7 +32861,7 @@ public class Hbase { __isset_bit_vector.clear(__SUCCESS_ISSET_ID); } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return __isset_bit_vector.get(__SUCCESS_ISSET_ID); } @@ -33974,7 +32883,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -34018,7 +32927,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -34085,7 +32994,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -34095,7 +33004,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -34107,34 +33016,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.I32) { + if (field.type == TType.I32) { this.success = iprot.readI32(); setSuccessIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -34144,7 +33053,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { @@ -34180,34 +33089,18 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class scannerOpenWithPrefix_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithPrefix_args"); - } - - public static class scannerOpenWithPrefix_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("scannerOpenWithPrefix_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField START_AND_PREFIX_FIELD_DESC = new org.apache.thrift.protocol.TField("startAndPrefix", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)3); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField START_AND_PREFIX_FIELD_DESC = new TField("startAndPrefix", TType.STRING, (short)2); + private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3); /** * name of table @@ -34223,7 +33116,7 @@ public class Hbase { public List columns; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -34297,18 +33190,18 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.START_AND_PREFIX, new org.apache.thrift.meta_data.FieldMetaData("startAndPrefix", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.START_AND_PREFIX, new FieldMetaData("startAndPrefix", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new FieldValueMetaData(TType.STRING , "Text")))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenWithPrefix_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(scannerOpenWithPrefix_args.class, metaDataMap); } public scannerOpenWithPrefix_args() { @@ -34359,11 +33252,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -34371,7 +33264,7 @@ public class Hbase { * name of table */ public scannerOpenWithPrefix_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -34384,7 +33277,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -34399,11 +33292,11 @@ public class Hbase { * the prefix (and thus start row) of the keys you want */ public byte[] getStartAndPrefix() { - setStartAndPrefix(org.apache.thrift.TBaseHelper.rightSize(startAndPrefix)); - return startAndPrefix == null ? null : startAndPrefix.array(); + setStartAndPrefix(TBaseHelper.rightSize(startAndPrefix)); + return startAndPrefix.array(); } - public ByteBuffer bufferForStartAndPrefix() { + public ByteBuffer BufferForStartAndPrefix() { return startAndPrefix; } @@ -34411,7 +33304,7 @@ public class Hbase { * the prefix (and thus start row) of the keys you want */ public scannerOpenWithPrefix_args setStartAndPrefix(byte[] startAndPrefix) { - setStartAndPrefix(startAndPrefix == null ? (ByteBuffer)null : ByteBuffer.wrap(startAndPrefix)); + setStartAndPrefix(ByteBuffer.wrap(startAndPrefix)); return this; } @@ -34424,7 +33317,7 @@ public class Hbase { this.startAndPrefix = null; } - /** Returns true if field startAndPrefix is set (has been assigned a value) and false otherwise */ + /** Returns true if field startAndPrefix is set (has been asigned a value) and false otherwise */ public boolean isSetStartAndPrefix() { return this.startAndPrefix != null; } @@ -34469,7 +33362,7 @@ public class Hbase { this.columns = null; } - /** Returns true if field columns is set (has been assigned a value) and false otherwise */ + /** Returns true if field columns is set (has been asigned a value) and false otherwise */ public boolean isSetColumns() { return this.columns != null; } @@ -34524,7 +33417,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -34602,7 +33495,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -34612,7 +33505,7 @@ public class Hbase { return lastComparison; } if (isSetStartAndPrefix()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startAndPrefix, typedOther.startAndPrefix); + lastComparison = TBaseHelper.compareTo(this.startAndPrefix, typedOther.startAndPrefix); if (lastComparison != 0) { return lastComparison; } @@ -34622,7 +33515,7 @@ public class Hbase { return lastComparison; } if (isSetColumns()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns); + lastComparison = TBaseHelper.compareTo(this.columns, typedOther.columns); if (lastComparison != 0) { return lastComparison; } @@ -34634,34 +33527,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // START_AND_PREFIX - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.startAndPrefix = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // COLUMNS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list130 = iprot.readListBegin(); + TList _list130 = iprot.readListBegin(); this.columns = new ArrayList(_list130.size); for (int _i131 = 0; _i131 < _list130.size; ++_i131) { @@ -34672,11 +33565,11 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -34686,7 +33579,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -34703,7 +33596,7 @@ public class Hbase { if (this.columns != null) { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); + oprot.writeListBegin(new TList(TType.STRING, this.columns.size())); for (ByteBuffer _iter133 : this.columns) { oprot.writeBinary(_iter133); @@ -34748,39 +33641,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class scannerOpenWithPrefix_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithPrefix_result"); - } - - public static class scannerOpenWithPrefix_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("scannerOpenWithPrefix_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.I32, (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 TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public int success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -34844,15 +33721,15 @@ public class Hbase { private static final int __SUCCESS_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "ScannerID"))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I32 , "ScannerID"))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenWithPrefix_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(scannerOpenWithPrefix_result.class, metaDataMap); } public scannerOpenWithPrefix_result() { @@ -34905,7 +33782,7 @@ public class Hbase { __isset_bit_vector.clear(__SUCCESS_ISSET_ID); } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return __isset_bit_vector.get(__SUCCESS_ISSET_ID); } @@ -34927,7 +33804,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -34971,7 +33848,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -35038,7 +33915,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -35048,7 +33925,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -35060,34 +33937,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.I32) { + if (field.type == TType.I32) { this.success = iprot.readI32(); setSuccessIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -35097,7 +33974,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { @@ -35133,35 +34010,19 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class scannerOpenTs_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("scannerOpenTs_args"); - } - - public static class scannerOpenTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("scannerOpenTs_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField START_ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("startRow", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)3); - private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)4); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2); + private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3); + private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4); /** * name of table @@ -35184,7 +34045,7 @@ public class Hbase { public long timestamp; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -35269,20 +34130,20 @@ public class Hbase { private static final int __TIMESTAMP_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.START_ROW, new org.apache.thrift.meta_data.FieldMetaData("startRow", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); - tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new FieldValueMetaData(TType.STRING , "Text")))); + tmpMap.put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I64))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenTs_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(scannerOpenTs_args.class, metaDataMap); } public scannerOpenTs_args() { @@ -35341,11 +34202,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -35353,7 +34214,7 @@ public class Hbase { * name of table */ public scannerOpenTs_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -35366,7 +34227,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -35382,11 +34243,11 @@ public class Hbase { * Send "" (empty string) to start at the first row. */ public byte[] getStartRow() { - setStartRow(org.apache.thrift.TBaseHelper.rightSize(startRow)); - return startRow == null ? null : startRow.array(); + setStartRow(TBaseHelper.rightSize(startRow)); + return startRow.array(); } - public ByteBuffer bufferForStartRow() { + public ByteBuffer BufferForStartRow() { return startRow; } @@ -35395,7 +34256,7 @@ public class Hbase { * Send "" (empty string) to start at the first row. */ public scannerOpenTs_args setStartRow(byte[] startRow) { - setStartRow(startRow == null ? (ByteBuffer)null : ByteBuffer.wrap(startRow)); + setStartRow(ByteBuffer.wrap(startRow)); return this; } @@ -35408,7 +34269,7 @@ public class Hbase { this.startRow = null; } - /** Returns true if field startRow is set (has been assigned a value) and false otherwise */ + /** Returns true if field startRow is set (has been asigned a value) and false otherwise */ public boolean isSetStartRow() { return this.startRow != null; } @@ -35457,7 +34318,7 @@ public class Hbase { this.columns = null; } - /** Returns true if field columns is set (has been assigned a value) and false otherwise */ + /** Returns true if field columns is set (has been asigned a value) and false otherwise */ public boolean isSetColumns() { return this.columns != null; } @@ -35488,7 +34349,7 @@ public class Hbase { __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); } - /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ + /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */ public boolean isSetTimestamp() { return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); } @@ -35552,7 +34413,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -35641,7 +34502,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -35651,7 +34512,7 @@ public class Hbase { return lastComparison; } if (isSetStartRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startRow, typedOther.startRow); + lastComparison = TBaseHelper.compareTo(this.startRow, typedOther.startRow); if (lastComparison != 0) { return lastComparison; } @@ -35661,7 +34522,7 @@ public class Hbase { return lastComparison; } if (isSetColumns()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns); + lastComparison = TBaseHelper.compareTo(this.columns, typedOther.columns); if (lastComparison != 0) { return lastComparison; } @@ -35671,7 +34532,7 @@ public class Hbase { return lastComparison; } if (isSetTimestamp()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + lastComparison = TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); if (lastComparison != 0) { return lastComparison; } @@ -35683,34 +34544,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // START_ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.startRow = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // COLUMNS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list134 = iprot.readListBegin(); + TList _list134 = iprot.readListBegin(); this.columns = new ArrayList(_list134.size); for (int _i135 = 0; _i135 < _list134.size; ++_i135) { @@ -35721,19 +34582,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 4: // TIMESTAMP - if (field.type == org.apache.thrift.protocol.TType.I64) { + if (field.type == TType.I64) { this.timestamp = iprot.readI64(); setTimestampIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -35743,7 +34604,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -35760,7 +34621,7 @@ public class Hbase { if (this.columns != null) { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); + oprot.writeListBegin(new TList(TType.STRING, this.columns.size())); for (ByteBuffer _iter137 : this.columns) { oprot.writeBinary(_iter137); @@ -35812,39 +34673,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class scannerOpenTs_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("scannerOpenTs_result"); - } - - public static class scannerOpenTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("scannerOpenTs_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.I32, (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 TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public int success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -35908,15 +34753,15 @@ public class Hbase { private static final int __SUCCESS_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "ScannerID"))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I32 , "ScannerID"))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenTs_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(scannerOpenTs_result.class, metaDataMap); } public scannerOpenTs_result() { @@ -35969,7 +34814,7 @@ public class Hbase { __isset_bit_vector.clear(__SUCCESS_ISSET_ID); } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return __isset_bit_vector.get(__SUCCESS_ISSET_ID); } @@ -35991,7 +34836,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -36035,7 +34880,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -36102,7 +34947,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -36112,7 +34957,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -36124,34 +34969,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.I32) { + if (field.type == TType.I32) { this.success = iprot.readI32(); setSuccessIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -36161,7 +35006,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { @@ -36197,36 +35042,20 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class scannerOpenWithStopTs_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStopTs_args"); - } - - public static class scannerOpenWithStopTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("scannerOpenWithStopTs_args"); - - private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField START_ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("startRow", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField STOP_ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("stopRow", org.apache.thrift.protocol.TType.STRING, (short)3); - private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)4); - private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)5); + private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1); + private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2); + private static final TField STOP_ROW_FIELD_DESC = new TField("stopRow", TType.STRING, (short)3); + private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)4); + private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)5); /** * name of table @@ -36254,7 +35083,7 @@ public class Hbase { public long timestamp; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * name of table */ @@ -36346,22 +35175,22 @@ public class Hbase { private static final int __TIMESTAMP_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.START_ROW, new org.apache.thrift.meta_data.FieldMetaData("startRow", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.STOP_ROW, new org.apache.thrift.meta_data.FieldMetaData("stopRow", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); - tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.STOP_ROW, new FieldMetaData("stopRow", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new FieldValueMetaData(TType.STRING , "Text")))); + tmpMap.put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I64))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenWithStopTs_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(scannerOpenWithStopTs_args.class, metaDataMap); } public scannerOpenWithStopTs_args() { @@ -36426,11 +35255,11 @@ public class Hbase { * name of table */ public byte[] getTableName() { - setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); - return tableName == null ? null : tableName.array(); + setTableName(TBaseHelper.rightSize(tableName)); + return tableName.array(); } - public ByteBuffer bufferForTableName() { + public ByteBuffer BufferForTableName() { return tableName; } @@ -36438,7 +35267,7 @@ public class Hbase { * name of table */ public scannerOpenWithStopTs_args setTableName(byte[] tableName) { - setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + setTableName(ByteBuffer.wrap(tableName)); return this; } @@ -36451,7 +35280,7 @@ public class Hbase { this.tableName = null; } - /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + /** Returns true if field tableName is set (has been asigned a value) and false otherwise */ public boolean isSetTableName() { return this.tableName != null; } @@ -36467,11 +35296,11 @@ public class Hbase { * Send "" (empty string) to start at the first row. */ public byte[] getStartRow() { - setStartRow(org.apache.thrift.TBaseHelper.rightSize(startRow)); - return startRow == null ? null : startRow.array(); + setStartRow(TBaseHelper.rightSize(startRow)); + return startRow.array(); } - public ByteBuffer bufferForStartRow() { + public ByteBuffer BufferForStartRow() { return startRow; } @@ -36480,7 +35309,7 @@ public class Hbase { * Send "" (empty string) to start at the first row. */ public scannerOpenWithStopTs_args setStartRow(byte[] startRow) { - setStartRow(startRow == null ? (ByteBuffer)null : ByteBuffer.wrap(startRow)); + setStartRow(ByteBuffer.wrap(startRow)); return this; } @@ -36493,7 +35322,7 @@ public class Hbase { this.startRow = null; } - /** Returns true if field startRow is set (has been assigned a value) and false otherwise */ + /** Returns true if field startRow is set (has been asigned a value) and false otherwise */ public boolean isSetStartRow() { return this.startRow != null; } @@ -36509,11 +35338,11 @@ public class Hbase { * scanner's results */ public byte[] getStopRow() { - setStopRow(org.apache.thrift.TBaseHelper.rightSize(stopRow)); - return stopRow == null ? null : stopRow.array(); + setStopRow(TBaseHelper.rightSize(stopRow)); + return stopRow.array(); } - public ByteBuffer bufferForStopRow() { + public ByteBuffer BufferForStopRow() { return stopRow; } @@ -36522,7 +35351,7 @@ public class Hbase { * scanner's results */ public scannerOpenWithStopTs_args setStopRow(byte[] stopRow) { - setStopRow(stopRow == null ? (ByteBuffer)null : ByteBuffer.wrap(stopRow)); + setStopRow(ByteBuffer.wrap(stopRow)); return this; } @@ -36535,7 +35364,7 @@ public class Hbase { this.stopRow = null; } - /** Returns true if field stopRow is set (has been assigned a value) and false otherwise */ + /** Returns true if field stopRow is set (has been asigned a value) and false otherwise */ public boolean isSetStopRow() { return this.stopRow != null; } @@ -36584,7 +35413,7 @@ public class Hbase { this.columns = null; } - /** Returns true if field columns is set (has been assigned a value) and false otherwise */ + /** Returns true if field columns is set (has been asigned a value) and false otherwise */ public boolean isSetColumns() { return this.columns != null; } @@ -36615,7 +35444,7 @@ public class Hbase { __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); } - /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ + /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */ public boolean isSetTimestamp() { return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); } @@ -36690,7 +35519,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -36790,7 +35619,7 @@ public class Hbase { return lastComparison; } if (isSetTableName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + lastComparison = TBaseHelper.compareTo(this.tableName, typedOther.tableName); if (lastComparison != 0) { return lastComparison; } @@ -36800,7 +35629,7 @@ public class Hbase { return lastComparison; } if (isSetStartRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startRow, typedOther.startRow); + lastComparison = TBaseHelper.compareTo(this.startRow, typedOther.startRow); if (lastComparison != 0) { return lastComparison; } @@ -36810,7 +35639,7 @@ public class Hbase { return lastComparison; } if (isSetStopRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.stopRow, typedOther.stopRow); + lastComparison = TBaseHelper.compareTo(this.stopRow, typedOther.stopRow); if (lastComparison != 0) { return lastComparison; } @@ -36820,7 +35649,7 @@ public class Hbase { return lastComparison; } if (isSetColumns()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns); + lastComparison = TBaseHelper.compareTo(this.columns, typedOther.columns); if (lastComparison != 0) { return lastComparison; } @@ -36830,7 +35659,7 @@ public class Hbase { return lastComparison; } if (isSetTimestamp()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + lastComparison = TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); if (lastComparison != 0) { return lastComparison; } @@ -36842,41 +35671,41 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // TABLE_NAME - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.tableName = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // START_ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.startRow = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // STOP_ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.stopRow = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 4: // COLUMNS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list138 = iprot.readListBegin(); + TList _list138 = iprot.readListBegin(); this.columns = new ArrayList(_list138.size); for (int _i139 = 0; _i139 < _list138.size; ++_i139) { @@ -36887,19 +35716,19 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 5: // TIMESTAMP - if (field.type == org.apache.thrift.protocol.TType.I64) { + if (field.type == TType.I64) { this.timestamp = iprot.readI64(); setTimestampIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -36909,7 +35738,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -36931,7 +35760,7 @@ public class Hbase { if (this.columns != null) { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); + oprot.writeListBegin(new TList(TType.STRING, this.columns.size())); for (ByteBuffer _iter141 : this.columns) { oprot.writeBinary(_iter141); @@ -36991,39 +35820,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class scannerOpenWithStopTs_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStopTs_result"); - } - - public static class scannerOpenWithStopTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("scannerOpenWithStopTs_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.I32, (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 TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); public int success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"); @@ -37087,15 +35900,15 @@ public class Hbase { private static final int __SUCCESS_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "ScannerID"))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I32 , "ScannerID"))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenWithStopTs_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(scannerOpenWithStopTs_result.class, metaDataMap); } public scannerOpenWithStopTs_result() { @@ -37148,7 +35961,7 @@ public class Hbase { __isset_bit_vector.clear(__SUCCESS_ISSET_ID); } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return __isset_bit_vector.get(__SUCCESS_ISSET_ID); } @@ -37170,7 +35983,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -37214,7 +36027,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -37281,7 +36094,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -37291,7 +36104,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -37303,34 +36116,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.I32) { + if (field.type == TType.I32) { this.success = iprot.readI32(); setSuccessIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -37340,7 +36153,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { @@ -37376,32 +36189,16 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class scannerGet_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("scannerGet_args"); - } - - public static class scannerGet_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("scannerGet_args"); - - private static final org.apache.thrift.protocol.TField ID_FIELD_DESC = new org.apache.thrift.protocol.TField("id", org.apache.thrift.protocol.TType.I32, (short)1); + private static final TField ID_FIELD_DESC = new TField("id", TType.I32, (short)1); /** * id of a scanner returned by scannerOpen @@ -37409,7 +36206,7 @@ public class Hbase { public int id; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * id of a scanner returned by scannerOpen */ @@ -37473,13 +36270,13 @@ public class Hbase { private static final int __ID_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.ID, new org.apache.thrift.meta_data.FieldMetaData("id", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "ScannerID"))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I32 , "ScannerID"))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerGet_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(scannerGet_args.class, metaDataMap); } public scannerGet_args() { @@ -37532,7 +36329,7 @@ public class Hbase { __isset_bit_vector.clear(__ID_ISSET_ID); } - /** Returns true if field id is set (has been assigned a value) and false otherwise */ + /** Returns true if field id is set (has been asigned a value) and false otherwise */ public boolean isSetId() { return __isset_bit_vector.get(__ID_ISSET_ID); } @@ -37563,7 +36360,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -37619,7 +36416,7 @@ public class Hbase { return lastComparison; } if (isSetId()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.id, typedOther.id); + lastComparison = TBaseHelper.compareTo(this.id, typedOther.id); if (lastComparison != 0) { return lastComparison; } @@ -37631,26 +36428,26 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // ID - if (field.type == org.apache.thrift.protocol.TType.I32) { + if (field.type == TType.I32) { this.id = iprot.readI32(); setIdIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -37660,7 +36457,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -37683,43 +36480,25 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class scannerGet_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("scannerGet_result"); - } - - public static class scannerGet_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("scannerGet_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); - private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); - private static final org.apache.thrift.protocol.TField IA_FIELD_DESC = new org.apache.thrift.protocol.TField("ia", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); + private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2); public List success; public IOError io; public IllegalArgument ia; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"), IA((short)2, "ia"); @@ -37784,18 +36563,18 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowResult.class)))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); - tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, TRowResult.class)))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); + tmpMap.put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerGet_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(scannerGet_result.class, metaDataMap); } public scannerGet_result() { @@ -37870,7 +36649,7 @@ public class Hbase { this.success = null; } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return this.success != null; } @@ -37894,7 +36673,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -37918,7 +36697,7 @@ public class Hbase { this.ia = null; } - /** Returns true if field ia is set (has been assigned a value) and false otherwise */ + /** Returns true if field ia is set (has been asigned a value) and false otherwise */ public boolean isSetIa() { return this.ia != null; } @@ -37973,7 +36752,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -38051,7 +36830,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -38061,7 +36840,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -38071,7 +36850,7 @@ public class Hbase { return lastComparison; } if (isSetIa()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, typedOther.ia); + lastComparison = TBaseHelper.compareTo(this.ia, typedOther.ia); if (lastComparison != 0) { return lastComparison; } @@ -38083,20 +36862,20 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list142 = iprot.readListBegin(); + TList _list142 = iprot.readListBegin(); this.success = new ArrayList(_list142.size); for (int _i143 = 0; _i143 < _list142.size; ++_i143) { @@ -38108,27 +36887,27 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // IA - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.ia = new IllegalArgument(); this.ia.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -38138,13 +36917,13 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.success.size())); for (TRowResult _iter145 : this.success) { _iter145.write(oprot); @@ -38197,33 +36976,17 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class scannerGetList_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("scannerGetList_args"); - } - - public static class scannerGetList_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("scannerGetList_args"); - - private static final org.apache.thrift.protocol.TField ID_FIELD_DESC = new org.apache.thrift.protocol.TField("id", org.apache.thrift.protocol.TType.I32, (short)1); - private static final org.apache.thrift.protocol.TField NB_ROWS_FIELD_DESC = new org.apache.thrift.protocol.TField("nbRows", org.apache.thrift.protocol.TType.I32, (short)2); + private static final TField ID_FIELD_DESC = new TField("id", TType.I32, (short)1); + private static final TField NB_ROWS_FIELD_DESC = new TField("nbRows", TType.I32, (short)2); /** * id of a scanner returned by scannerOpen @@ -38235,7 +36998,7 @@ public class Hbase { public int nbRows; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * id of a scanner returned by scannerOpen */ @@ -38306,15 +37069,15 @@ public class Hbase { private static final int __NBROWS_ISSET_ID = 1; private BitSet __isset_bit_vector = new BitSet(2); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.ID, new org.apache.thrift.meta_data.FieldMetaData("id", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "ScannerID"))); - tmpMap.put(_Fields.NB_ROWS, new org.apache.thrift.meta_data.FieldMetaData("nbRows", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I32 , "ScannerID"))); + tmpMap.put(_Fields.NB_ROWS, new FieldMetaData("nbRows", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I32))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerGetList_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(scannerGetList_args.class, metaDataMap); } public scannerGetList_args() { @@ -38373,7 +37136,7 @@ public class Hbase { __isset_bit_vector.clear(__ID_ISSET_ID); } - /** Returns true if field id is set (has been assigned a value) and false otherwise */ + /** Returns true if field id is set (has been asigned a value) and false otherwise */ public boolean isSetId() { return __isset_bit_vector.get(__ID_ISSET_ID); } @@ -38402,7 +37165,7 @@ public class Hbase { __isset_bit_vector.clear(__NBROWS_ISSET_ID); } - /** Returns true if field nbRows is set (has been assigned a value) and false otherwise */ + /** Returns true if field nbRows is set (has been asigned a value) and false otherwise */ public boolean isSetNbRows() { return __isset_bit_vector.get(__NBROWS_ISSET_ID); } @@ -38444,7 +37207,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -38511,7 +37274,7 @@ public class Hbase { return lastComparison; } if (isSetId()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.id, typedOther.id); + lastComparison = TBaseHelper.compareTo(this.id, typedOther.id); if (lastComparison != 0) { return lastComparison; } @@ -38521,7 +37284,7 @@ public class Hbase { return lastComparison; } if (isSetNbRows()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nbRows, typedOther.nbRows); + lastComparison = TBaseHelper.compareTo(this.nbRows, typedOther.nbRows); if (lastComparison != 0) { return lastComparison; } @@ -38533,34 +37296,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // ID - if (field.type == org.apache.thrift.protocol.TType.I32) { + if (field.type == TType.I32) { this.id = iprot.readI32(); setIdIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // NB_ROWS - if (field.type == org.apache.thrift.protocol.TType.I32) { + if (field.type == TType.I32) { this.nbRows = iprot.readI32(); setNbRowsIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -38570,7 +37333,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -38600,41 +37363,25 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class scannerGetList_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("scannerGetList_result"); - } - - public static class scannerGetList_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("scannerGetList_result"); - - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); - private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); - private static final org.apache.thrift.protocol.TField IA_FIELD_DESC = new org.apache.thrift.protocol.TField("ia", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); + private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2); public List success; public IOError io; public IllegalArgument ia; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { SUCCESS((short)0, "success"), IO((short)1, "io"), IA((short)2, "ia"); @@ -38699,18 +37446,18 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, FieldMetaData> metaDataMap; static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowResult.class)))); - tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); - tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, + new ListMetaData(TType.LIST, + new StructMetaData(TType.STRUCT, TRowResult.class)))); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); + tmpMap.put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerGetList_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(scannerGetList_result.class, metaDataMap); } public scannerGetList_result() { @@ -38785,7 +37532,7 @@ public class Hbase { this.success = null; } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ + /** Returns true if field success is set (has been asigned a value) and false otherwise */ public boolean isSetSuccess() { return this.success != null; } @@ -38809,7 +37556,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -38833,7 +37580,7 @@ public class Hbase { this.ia = null; } - /** Returns true if field ia is set (has been assigned a value) and false otherwise */ + /** Returns true if field ia is set (has been asigned a value) and false otherwise */ public boolean isSetIa() { return this.ia != null; } @@ -38888,7 +37635,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -38966,7 +37713,7 @@ public class Hbase { return lastComparison; } if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + lastComparison = TBaseHelper.compareTo(this.success, typedOther.success); if (lastComparison != 0) { return lastComparison; } @@ -38976,7 +37723,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -38986,7 +37733,7 @@ public class Hbase { return lastComparison; } if (isSetIa()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, typedOther.ia); + lastComparison = TBaseHelper.compareTo(this.ia, typedOther.ia); if (lastComparison != 0) { return lastComparison; } @@ -38998,20 +37745,20 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list146 = iprot.readListBegin(); + TList _list146 = iprot.readListBegin(); this.success = new ArrayList(_list146.size); for (int _i147 = 0; _i147 < _list146.size; ++_i147) { @@ -39023,27 +37770,27 @@ public class Hbase { iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // IA - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.ia = new IllegalArgument(); this.ia.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -39053,13 +37800,13 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetSuccess()) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); + oprot.writeListBegin(new TList(TType.STRUCT, this.success.size())); for (TRowResult _iter149 : this.success) { _iter149.write(oprot); @@ -39112,32 +37859,16 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class scannerClose_args implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("scannerClose_args"); - } - - public static class scannerClose_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("scannerClose_args"); - - private static final org.apache.thrift.protocol.TField ID_FIELD_DESC = new org.apache.thrift.protocol.TField("id", org.apache.thrift.protocol.TType.I32, (short)1); + private static final TField ID_FIELD_DESC = new TField("id", TType.I32, (short)1); /** * id of a scanner returned by scannerOpen @@ -39145,7 +37876,7 @@ public class Hbase { public int id; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { /** * id of a scanner returned by scannerOpen */ @@ -39209,13 +37940,13 @@ public class Hbase { private static final int __ID_ISSET_ID = 0; private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.ID, new org.apache.thrift.meta_data.FieldMetaData("id", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "ScannerID"))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.I32 , "ScannerID"))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerClose_args.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(scannerClose_args.class, metaDataMap); } public scannerClose_args() { @@ -39268,7 +37999,7 @@ public class Hbase { __isset_bit_vector.clear(__ID_ISSET_ID); } - /** Returns true if field id is set (has been assigned a value) and false otherwise */ + /** Returns true if field id is set (has been asigned a value) and false otherwise */ public boolean isSetId() { return __isset_bit_vector.get(__ID_ISSET_ID); } @@ -39299,7 +38030,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -39355,7 +38086,7 @@ public class Hbase { return lastComparison; } if (isSetId()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.id, typedOther.id); + lastComparison = TBaseHelper.compareTo(this.id, typedOther.id); if (lastComparison != 0) { return lastComparison; } @@ -39367,26 +38098,26 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // ID - if (field.type == org.apache.thrift.protocol.TType.I32) { + if (field.type == TType.I32) { this.id = iprot.readI32(); setIdIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -39396,7 +38127,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -39419,41 +38150,23 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } + public static class scannerClose_result implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("scannerClose_result"); - } - - public static class scannerClose_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("scannerClose_result"); - - 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.protocol.TField IA_FIELD_DESC = new org.apache.thrift.protocol.TField("ia", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1); + private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2); public IOError io; public IllegalArgument ia; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { IO((short)1, "io"), IA((short)2, "ia"); @@ -39515,15 +38228,15 @@ public class Hbase { // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); - tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); + tmpMap.put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT, + new FieldValueMetaData(TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerClose_result.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(scannerClose_result.class, metaDataMap); } public scannerClose_result() { @@ -39573,7 +38286,7 @@ public class Hbase { this.io = null; } - /** Returns true if field io is set (has been assigned a value) and false otherwise */ + /** Returns true if field io is set (has been asigned a value) and false otherwise */ public boolean isSetIo() { return this.io != null; } @@ -39597,7 +38310,7 @@ public class Hbase { this.ia = null; } - /** Returns true if field ia is set (has been assigned a value) and false otherwise */ + /** Returns true if field ia is set (has been asigned a value) and false otherwise */ public boolean isSetIa() { return this.ia != null; } @@ -39641,7 +38354,7 @@ public class Hbase { throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -39708,7 +38421,7 @@ public class Hbase { return lastComparison; } if (isSetIo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + lastComparison = TBaseHelper.compareTo(this.io, typedOther.io); if (lastComparison != 0) { return lastComparison; } @@ -39718,7 +38431,7 @@ public class Hbase { return lastComparison; } if (isSetIa()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, typedOther.ia); + lastComparison = TBaseHelper.compareTo(this.ia, typedOther.ia); if (lastComparison != 0) { return lastComparison; } @@ -39730,34 +38443,34 @@ public class Hbase { return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // IO - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.io = new IOError(); this.io.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // IA - if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + if (field.type == TType.STRUCT) { this.ia = new IllegalArgument(); this.ia.read(iprot); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -39767,7 +38480,7 @@ public class Hbase { validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { oprot.writeStructBegin(STRUCT_DESC); if (this.isSetIo()) { @@ -39807,26 +38520,10 @@ public class Hbase { return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); } - } - - } - -} diff --git a/src/main/java/org/apache/hadoop/hbase/thrift/generated/TScan.java b/src/main/java/org/apache/hadoop/hbase/thrift/generated/TScan.java index 2512a3f982d..dfe5aafe421 100644 --- a/src/main/java/org/apache/hadoop/hbase/thrift/generated/TScan.java +++ b/src/main/java/org/apache/hadoop/hbase/thrift/generated/TScan.java @@ -20,31 +20,40 @@ import java.util.Arrays; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.apache.thrift.*; +import org.apache.thrift.async.*; +import org.apache.thrift.meta_data.*; +import org.apache.thrift.transport.*; +import org.apache.thrift.protocol.*; + /** * A Scan object is used to specify scanner parameters when opening a scanner. */ -public class TScan 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("TScan"); +public class TScan implements TBase, java.io.Serializable, Cloneable { + private static final TStruct STRUCT_DESC = new TStruct("TScan"); - private static final org.apache.thrift.protocol.TField START_ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("startRow", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField STOP_ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("stopRow", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)3); - private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)4); - private static final org.apache.thrift.protocol.TField CACHING_FIELD_DESC = new org.apache.thrift.protocol.TField("caching", org.apache.thrift.protocol.TType.I32, (short)5); + private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)1); + private static final TField STOP_ROW_FIELD_DESC = new TField("stopRow", TType.STRING, (short)2); + private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3); + private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)4); + private static final TField CACHING_FIELD_DESC = new TField("caching", TType.I32, (short)5); + private static final TField FILTER_STRING_FIELD_DESC = new TField("filterString", TType.STRING, (short)6); public ByteBuffer startRow; public ByteBuffer stopRow; public long timestamp; public List columns; public int caching; + public ByteBuffer filterString; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { + public enum _Fields implements TFieldIdEnum { START_ROW((short)1, "startRow"), STOP_ROW((short)2, "stopRow"), TIMESTAMP((short)3, "timestamp"), COLUMNS((short)4, "columns"), - CACHING((short)5, "caching"); + CACHING((short)5, "caching"), + FILTER_STRING((short)6, "filterString"); private static final Map byName = new HashMap(); @@ -69,6 +78,8 @@ public class TScan implements org.apache.thrift.TBase, jav return COLUMNS; case 5: // CACHING return CACHING; + case 6: // FILTER_STRING + return FILTER_STRING; default: return null; } @@ -113,22 +124,24 @@ public class TScan implements org.apache.thrift.TBase, jav private static final int __CACHING_ISSET_ID = 1; private BitSet __isset_bit_vector = new BitSet(2); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + public static final Map<_Fields, 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.START_ROW, new org.apache.thrift.meta_data.FieldMetaData("startRow", org.apache.thrift.TFieldRequirementType.OPTIONAL, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.STOP_ROW, new org.apache.thrift.meta_data.FieldMetaData("stopRow", org.apache.thrift.TFieldRequirementType.OPTIONAL, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.OPTIONAL, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); - tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.OPTIONAL, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); - tmpMap.put(_Fields.CACHING, new org.apache.thrift.meta_data.FieldMetaData("caching", org.apache.thrift.TFieldRequirementType.OPTIONAL, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.OPTIONAL, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.STOP_ROW, new FieldMetaData("stopRow", TFieldRequirementType.OPTIONAL, + new FieldValueMetaData(TType.STRING , "Text"))); + tmpMap.put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.OPTIONAL, + new FieldValueMetaData(TType.I64))); + tmpMap.put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.OPTIONAL, + new ListMetaData(TType.LIST, + new FieldValueMetaData(TType.STRING , "Text")))); + tmpMap.put(_Fields.CACHING, new FieldMetaData("caching", TFieldRequirementType.OPTIONAL, + new FieldValueMetaData(TType.I32))); + tmpMap.put(_Fields.FILTER_STRING, new FieldMetaData("filterString", TFieldRequirementType.OPTIONAL, + new FieldValueMetaData(TType.STRING , "Text"))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TScan.class, metaDataMap); + FieldMetaData.addStructMetaDataMap(TScan.class, metaDataMap); } public TScan() { @@ -155,6 +168,9 @@ public class TScan implements org.apache.thrift.TBase, jav this.columns = __this__columns; } this.caching = other.caching; + if (other.isSetFilterString()) { + this.filterString = other.filterString; + } } public TScan deepCopy() { @@ -170,19 +186,20 @@ public class TScan implements org.apache.thrift.TBase, jav this.columns = null; setCachingIsSet(false); this.caching = 0; + this.filterString = null; } public byte[] getStartRow() { - setStartRow(org.apache.thrift.TBaseHelper.rightSize(startRow)); - return startRow == null ? null : startRow.array(); + setStartRow(TBaseHelper.rightSize(startRow)); + return startRow.array(); } - public ByteBuffer bufferForStartRow() { + public ByteBuffer BufferForStartRow() { return startRow; } public TScan setStartRow(byte[] startRow) { - setStartRow(startRow == null ? (ByteBuffer)null : ByteBuffer.wrap(startRow)); + setStartRow(ByteBuffer.wrap(startRow)); return this; } @@ -195,7 +212,7 @@ public class TScan implements org.apache.thrift.TBase, jav this.startRow = null; } - /** Returns true if field startRow is set (has been assigned a value) and false otherwise */ + /** Returns true if field startRow is set (has been asigned a value) and false otherwise */ public boolean isSetStartRow() { return this.startRow != null; } @@ -207,16 +224,16 @@ public class TScan implements org.apache.thrift.TBase, jav } public byte[] getStopRow() { - setStopRow(org.apache.thrift.TBaseHelper.rightSize(stopRow)); - return stopRow == null ? null : stopRow.array(); + setStopRow(TBaseHelper.rightSize(stopRow)); + return stopRow.array(); } - public ByteBuffer bufferForStopRow() { + public ByteBuffer BufferForStopRow() { return stopRow; } public TScan setStopRow(byte[] stopRow) { - setStopRow(stopRow == null ? (ByteBuffer)null : ByteBuffer.wrap(stopRow)); + setStopRow(ByteBuffer.wrap(stopRow)); return this; } @@ -229,7 +246,7 @@ public class TScan implements org.apache.thrift.TBase, jav this.stopRow = null; } - /** Returns true if field stopRow is set (has been assigned a value) and false otherwise */ + /** Returns true if field stopRow is set (has been asigned a value) and false otherwise */ public boolean isSetStopRow() { return this.stopRow != null; } @@ -254,7 +271,7 @@ public class TScan implements org.apache.thrift.TBase, jav __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); } - /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ + /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */ public boolean isSetTimestamp() { return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); } @@ -291,7 +308,7 @@ public class TScan implements org.apache.thrift.TBase, jav this.columns = null; } - /** Returns true if field columns is set (has been assigned a value) and false otherwise */ + /** Returns true if field columns is set (has been asigned a value) and false otherwise */ public boolean isSetColumns() { return this.columns != null; } @@ -316,7 +333,7 @@ public class TScan implements org.apache.thrift.TBase, jav __isset_bit_vector.clear(__CACHING_ISSET_ID); } - /** Returns true if field caching is set (has been assigned a value) and false otherwise */ + /** Returns true if field caching is set (has been asigned a value) and false otherwise */ public boolean isSetCaching() { return __isset_bit_vector.get(__CACHING_ISSET_ID); } @@ -325,6 +342,40 @@ public class TScan implements org.apache.thrift.TBase, jav __isset_bit_vector.set(__CACHING_ISSET_ID, value); } + public byte[] getFilterString() { + setFilterString(TBaseHelper.rightSize(filterString)); + return filterString.array(); + } + + public ByteBuffer BufferForFilterString() { + return filterString; + } + + public TScan setFilterString(byte[] filterString) { + setFilterString(ByteBuffer.wrap(filterString)); + return this; + } + + public TScan setFilterString(ByteBuffer filterString) { + this.filterString = filterString; + return this; + } + + public void unsetFilterString() { + this.filterString = null; + } + + /** Returns true if field filterString is set (has been asigned a value) and false otherwise */ + public boolean isSetFilterString() { + return this.filterString != null; + } + + public void setFilterStringIsSet(boolean value) { + if (!value) { + this.filterString = null; + } + } + public void setFieldValue(_Fields field, Object value) { switch (field) { case START_ROW: @@ -367,7 +418,15 @@ public class TScan implements org.apache.thrift.TBase, jav } break; + case FILTER_STRING: + if (value == null) { + unsetFilterString(); + } else { + setFilterString((ByteBuffer)value); } + break; + + } } public Object getFieldValue(_Fields field) { @@ -387,11 +446,14 @@ public class TScan implements org.apache.thrift.TBase, jav case CACHING: return new Integer(getCaching()); + case FILTER_STRING: + return getFilterString(); + } throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); @@ -408,6 +470,8 @@ public class TScan implements org.apache.thrift.TBase, jav return isSetColumns(); case CACHING: return isSetCaching(); + case FILTER_STRING: + return isSetFilterString(); } throw new IllegalStateException(); } @@ -470,6 +534,15 @@ public class TScan implements org.apache.thrift.TBase, jav return false; } + boolean this_present_filterString = true && this.isSetFilterString(); + boolean that_present_filterString = true && that.isSetFilterString(); + if (this_present_filterString || that_present_filterString) { + if (!(this_present_filterString && that_present_filterString)) + return false; + if (!this.filterString.equals(that.filterString)) + return false; + } + return true; } @@ -491,7 +564,7 @@ public class TScan implements org.apache.thrift.TBase, jav return lastComparison; } if (isSetStartRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startRow, typedOther.startRow); + lastComparison = TBaseHelper.compareTo(this.startRow, typedOther.startRow); if (lastComparison != 0) { return lastComparison; } @@ -501,7 +574,7 @@ public class TScan implements org.apache.thrift.TBase, jav return lastComparison; } if (isSetStopRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.stopRow, typedOther.stopRow); + lastComparison = TBaseHelper.compareTo(this.stopRow, typedOther.stopRow); if (lastComparison != 0) { return lastComparison; } @@ -511,7 +584,7 @@ public class TScan implements org.apache.thrift.TBase, jav return lastComparison; } if (isSetTimestamp()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + lastComparison = TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); if (lastComparison != 0) { return lastComparison; } @@ -521,7 +594,7 @@ public class TScan implements org.apache.thrift.TBase, jav return lastComparison; } if (isSetColumns()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns); + lastComparison = TBaseHelper.compareTo(this.columns, typedOther.columns); if (lastComparison != 0) { return lastComparison; } @@ -531,7 +604,17 @@ public class TScan implements org.apache.thrift.TBase, jav return lastComparison; } if (isSetCaching()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.caching, typedOther.caching); + lastComparison = TBaseHelper.compareTo(this.caching, typedOther.caching); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetFilterString()).compareTo(typedOther.isSetFilterString()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFilterString()) { + lastComparison = TBaseHelper.compareTo(this.filterString, typedOther.filterString); if (lastComparison != 0) { return lastComparison; } @@ -543,42 +626,42 @@ public class TScan implements org.apache.thrift.TBase, jav return _Fields.findByThriftId(fieldId); } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField field; + public void read(TProtocol iprot) throws TException { + TField field; iprot.readStructBegin(); while (true) { field = iprot.readFieldBegin(); - if (field.type == org.apache.thrift.protocol.TType.STOP) { + if (field.type == TType.STOP) { break; } switch (field.id) { case 1: // START_ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.startRow = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 2: // STOP_ROW - if (field.type == org.apache.thrift.protocol.TType.STRING) { + if (field.type == TType.STRING) { this.stopRow = iprot.readBinary(); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 3: // TIMESTAMP - if (field.type == org.apache.thrift.protocol.TType.I64) { + if (field.type == TType.I64) { this.timestamp = iprot.readI64(); setTimestampIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 4: // COLUMNS - if (field.type == org.apache.thrift.protocol.TType.LIST) { + if (field.type == TType.LIST) { { - org.apache.thrift.protocol.TList _list9 = iprot.readListBegin(); + TList _list9 = iprot.readListBegin(); this.columns = new ArrayList(_list9.size); for (int _i10 = 0; _i10 < _list9.size; ++_i10) { @@ -589,19 +672,26 @@ public class TScan implements org.apache.thrift.TBase, jav iprot.readListEnd(); } } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } break; case 5: // CACHING - if (field.type == org.apache.thrift.protocol.TType.I32) { + if (field.type == TType.I32) { this.caching = iprot.readI32(); setCachingIsSet(true); } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); + } + break; + case 6: // FILTER_STRING + if (field.type == TType.STRING) { + this.filterString = iprot.readBinary(); + } else { + TProtocolUtil.skip(iprot, field.type); } break; default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + TProtocolUtil.skip(iprot, field.type); } iprot.readFieldEnd(); } @@ -611,7 +701,7 @@ public class TScan implements org.apache.thrift.TBase, jav validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + public void write(TProtocol oprot) throws TException { validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -638,7 +728,7 @@ public class TScan implements org.apache.thrift.TBase, jav if (isSetColumns()) { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); + oprot.writeListBegin(new TList(TType.STRING, this.columns.size())); for (ByteBuffer _iter12 : this.columns) { oprot.writeBinary(_iter12); @@ -653,6 +743,13 @@ public class TScan implements org.apache.thrift.TBase, jav oprot.writeI32(this.caching); oprot.writeFieldEnd(); } + if (this.filterString != null) { + if (isSetFilterString()) { + oprot.writeFieldBegin(FILTER_STRING_FIELD_DESC); + oprot.writeBinary(this.filterString); + oprot.writeFieldEnd(); + } + } oprot.writeFieldStop(); oprot.writeStructEnd(); } @@ -703,31 +800,23 @@ public class TScan implements org.apache.thrift.TBase, jav sb.append(this.caching); first = false; } + if (isSetFilterString()) { + if (!first) sb.append(", "); + sb.append("filterString:"); + if (this.filterString == null) { + sb.append("null"); + } else { + sb.append(this.filterString); + } + first = false; + } sb.append(")"); return sb.toString(); } - public void validate() throws org.apache.thrift.TException { + public void validate() throws 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); - } - } - -} diff --git a/src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift b/src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift index 9650a9c4327..57985c17419 100644 --- a/src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift +++ b/src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift @@ -124,7 +124,8 @@ struct TScan { 2:optional Text stopRow, 3:optional i64 timestamp, 4:optional list columns, - 5:optional i32 caching + 5:optional i32 caching, + 6:optional Text filterString } // diff --git a/src/main/ruby/hbase/table.rb b/src/main/ruby/hbase/table.rb index f4c2637e3d8..f9433d45483 100644 --- a/src/main/ruby/hbase/table.rb +++ b/src/main/ruby/hbase/table.rb @@ -236,7 +236,13 @@ module Hbase end columns.each { |c| scan.addColumns(c) } - scan.setFilter(filter) if filter + + unless filter.class == String + scan.setFilter(filter) + else + scan.setFilter(org.apache.hadoop.hbase.filter.ParseFilter.new.parseFilterString(filter)) + end + scan.setTimeStamp(timestamp) if timestamp scan.setCacheBlocks(cache) scan.setMaxVersions(versions) if versions > 1 diff --git a/src/main/ruby/shell/commands/scan.rb b/src/main/ruby/shell/commands/scan.rb index c68c6f1673b..378bd6c3153 100644 --- a/src/main/ruby/shell/commands/scan.rb +++ b/src/main/ruby/shell/commands/scan.rb @@ -26,17 +26,25 @@ module Shell Scan a table; pass table name and optionally a dictionary of scanner specifications. Scanner specifications may include one or more of: TIMERANGE, FILTER, LIMIT, STARTROW, STOPROW, TIMESTAMP, MAXLENGTH, -or COLUMNS. If no columns are specified, all columns will be scanned. +or COLUMNS. + +If no columns are specified, all columns will be scanned. To scan all members of a column family, leave the qualifier empty as in 'col_family:'. +The filter can be specified in two ways: +1. Using a filterString - more information on this is available in the +Filter Language document attached to the HBASE-4176 JIRA +2. Using the entire package name of the filter. + Some examples: hbase> scan '.META.' hbase> scan '.META.', {COLUMNS => 'info:regioninfo'} hbase> scan 't1', {COLUMNS => ['c1', 'c2'], LIMIT => 10, STARTROW => 'xyz'} - hbase> scan 't1', {FILTER => org.apache.hadoop.hbase.filter.ColumnPaginationFilter.new(1, 0)} hbase> scan 't1', {COLUMNS => 'c1', TIMERANGE => [1303668804, 1303668904]} + hbase> scan 't1', {FILTER => "(PrefixFilter ('row2') AND (QualifierFilter (>=, 'binary:xyz'))) AND (TimestampsFilter ( 123, 456))"} + hbase> scan 't1', {FILTER => org.apache.hadoop.hbase.filter.ColumnPaginationFilter.new(1, 0)} For experts, there is an additional option -- CACHE_BLOCKS -- which switches block caching for the scanner on (true) or off (false). By diff --git a/src/test/java/org/apache/hadoop/hbase/filter/TestParseFilter.java b/src/test/java/org/apache/hadoop/hbase/filter/TestParseFilter.java index e69de29bb2d..76b92b80971 100644 --- a/src/test/java/org/apache/hadoop/hbase/filter/TestParseFilter.java +++ b/src/test/java/org/apache/hadoop/hbase/filter/TestParseFilter.java @@ -0,0 +1,663 @@ +/** + * Copyright 2011 The Apache Software Foundation + * + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hbase.filter; + +import static org.junit.Assert.*; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.TreeSet; + +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.HColumnDescriptor; +import org.apache.hadoop.hbase.HRegionInfo; +import org.apache.hadoop.hbase.HTableDescriptor; +import org.apache.hadoop.hbase.KeyValue; +import org.apache.hadoop.hbase.KeyValueTestUtil; +import org.apache.hadoop.hbase.client.Put; +import org.apache.hadoop.hbase.client.Scan; +import org.apache.hadoop.hbase.regionserver.HRegion; +import org.apache.hadoop.hbase.regionserver.InternalScanner; +import org.apache.hadoop.hbase.util.Bytes; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +/** + * This class tests ParseFilter.java + * It tests the entire work flow from when a string is given by the user + * and how it is parsed to construct the corresponding Filter object + */ +public class TestParseFilter { + + ParseFilter f; + Filter filter; + + @Before + public void setUp() throws Exception { + f = new ParseFilter(); + } + + @After + public void tearDown() throws Exception { + // Nothing to do. + } + + @Test + public void testKeyOnlyFilter() throws IOException { + String filterString = "KeyOnlyFilter()"; + doTestFilter(filterString, KeyOnlyFilter.class); + + String filterString2 = "KeyOnlyFilter ('') "; + byte [] filterStringAsByteArray2 = Bytes.toBytes(filterString2); + try { + filter = f.parseFilterString(filterStringAsByteArray2); + assertTrue(false); + } catch (IllegalArgumentException e) { + System.out.println(e.getMessage()); + } + } + + @Test + public void testFirstKeyOnlyFilter() throws IOException { + String filterString = " FirstKeyOnlyFilter( ) "; + doTestFilter(filterString, FirstKeyOnlyFilter.class); + + String filterString2 = " FirstKeyOnlyFilter ('') "; + byte [] filterStringAsByteArray2 = Bytes.toBytes(filterString2); + try { + filter = f.parseFilterString(filterStringAsByteArray2); + assertTrue(false); + } catch (IllegalArgumentException e) { + System.out.println(e.getMessage()); + } + } + + @Test + public void testPrefixFilter() throws IOException { + String filterString = " PrefixFilter('row' ) "; + PrefixFilter prefixFilter = doTestFilter(filterString, PrefixFilter.class); + byte [] prefix = prefixFilter.getPrefix(); + assertEquals(new String(prefix), "row"); + + + filterString = " PrefixFilter(row)"; + try { + doTestFilter(filterString, PrefixFilter.class); + assertTrue(false); + } catch (IllegalArgumentException e) { + System.out.println(e.getMessage()); + } + } + + @Test + public void testColumnPrefixFilter() throws IOException { + String filterString = " ColumnPrefixFilter('qualifier' ) "; + ColumnPrefixFilter columnPrefixFilter = + doTestFilter(filterString, ColumnPrefixFilter.class); + byte [] columnPrefix = columnPrefixFilter.getPrefix(); + assertEquals(new String(columnPrefix), "qualifier"); + } + + @Test + public void testMultipleColumnPrefixFilter() throws IOException { + String filterString = " MultipleColumnPrefixFilter('qualifier1', 'qualifier2' ) "; + MultipleColumnPrefixFilter multipleColumnPrefixFilter = + doTestFilter(filterString, MultipleColumnPrefixFilter.class); + byte [][] prefixes = multipleColumnPrefixFilter.getPrefix(); + assertEquals(new String(prefixes[0]), "qualifier1"); + assertEquals(new String(prefixes[1]), "qualifier2"); + } + + @Test + public void testColumnCountGetFilter() throws IOException { + String filterString = " ColumnCountGetFilter(4)"; + ColumnCountGetFilter columnCountGetFilter = + doTestFilter(filterString, ColumnCountGetFilter.class); + int limit = columnCountGetFilter.getLimit(); + assertEquals(limit, 4); + + filterString = " ColumnCountGetFilter('abc')"; + try { + doTestFilter(filterString, ColumnCountGetFilter.class); + assertTrue(false); + } catch (IllegalArgumentException e) { + System.out.println(e.getMessage()); + } + + filterString = " ColumnCountGetFilter(2147483648)"; + try { + doTestFilter(filterString, ColumnCountGetFilter.class); + assertTrue(false); + } catch (IllegalArgumentException e) { + System.out.println(e.getMessage()); + } + } + + @Test + public void testPageFilter() throws IOException { + String filterString = " PageFilter(4)"; + PageFilter pageFilter = + doTestFilter(filterString, PageFilter.class); + long pageSize = pageFilter.getPageSize(); + assertEquals(pageSize, 4); + + filterString = " PageFilter('123')"; + try { + doTestFilter(filterString, PageFilter.class); + assertTrue(false); + } catch (IllegalArgumentException e) { + System.out.println("PageFilter needs an int as an argument"); + } + } + + @Test + public void testColumnPaginationFilter() throws IOException { + String filterString = "ColumnPaginationFilter(4, 6)"; + ColumnPaginationFilter columnPaginationFilter = + doTestFilter(filterString, ColumnPaginationFilter.class); + int limit = columnPaginationFilter.getLimit(); + assertEquals(limit, 4); + int offset = columnPaginationFilter.getOffset(); + assertEquals(offset, 6); + + filterString = " ColumnPaginationFilter('124')"; + try { + doTestFilter(filterString, ColumnPaginationFilter.class); + assertTrue(false); + } catch (IllegalArgumentException e) { + System.out.println("ColumnPaginationFilter needs two arguments"); + } + + filterString = " ColumnPaginationFilter('4' , '123a')"; + try { + doTestFilter(filterString, ColumnPaginationFilter.class); + assertTrue(false); + } catch (IllegalArgumentException e) { + System.out.println("ColumnPaginationFilter needs two ints as arguments"); + } + + filterString = " ColumnPaginationFilter('4' , '-123')"; + try { + doTestFilter(filterString, ColumnPaginationFilter.class); + assertTrue(false); + } catch (IllegalArgumentException e) { + System.out.println("ColumnPaginationFilter arguments should not be negative"); + } + } + + @Test + public void testInclusiveStopFilter() throws IOException { + String filterString = "InclusiveStopFilter ('row 3')"; + InclusiveStopFilter inclusiveStopFilter = + doTestFilter(filterString, InclusiveStopFilter.class); + byte [] stopRowKey = inclusiveStopFilter.getStopRowKey(); + assertEquals(new String(stopRowKey), "row 3"); + } + + + @Test + public void testTimestampsFilter() throws IOException { + String filterString = "TimestampsFilter(9223372036854775806, 6)"; + TimestampsFilter timestampsFilter = + doTestFilter(filterString, TimestampsFilter.class); + List timestamps = timestampsFilter.getTimestamps(); + assertEquals(timestamps.size(), 2); + assertEquals(timestamps.get(0), new Long(6)); + + filterString = "TimestampsFilter()"; + timestampsFilter = doTestFilter(filterString, TimestampsFilter.class); + timestamps = timestampsFilter.getTimestamps(); + assertEquals(timestamps.size(), 0); + + filterString = "TimestampsFilter(9223372036854775808, 6)"; + try { + doTestFilter(filterString, ColumnPaginationFilter.class); + assertTrue(false); + } catch (IllegalArgumentException e) { + System.out.println("Long Argument was too large"); + } + + filterString = "TimestampsFilter(-45, 6)"; + try { + doTestFilter(filterString, ColumnPaginationFilter.class); + assertTrue(false); + } catch (IllegalArgumentException e) { + System.out.println("Timestamp Arguments should not be negative"); + } + } + + @Test + public void testRowFilter() throws IOException { + String filterString = "RowFilter ( =, 'binary:regionse')"; + RowFilter rowFilter = + doTestFilter(filterString, RowFilter.class); + assertEquals(CompareFilter.CompareOp.EQUAL, rowFilter.getOperator()); + assertTrue(rowFilter.getComparator() instanceof BinaryComparator); + BinaryComparator binaryComparator = (BinaryComparator) rowFilter.getComparator(); + assertEquals("regionse", new String(binaryComparator.getValue())); + } + + @Test + public void testFamilyFilter() throws IOException { + String filterString = "FamilyFilter(>=, 'binaryprefix:pre')"; + FamilyFilter familyFilter = + doTestFilter(filterString, FamilyFilter.class); + assertEquals(CompareFilter.CompareOp.GREATER_OR_EQUAL, familyFilter.getOperator()); + assertTrue(familyFilter.getComparator() instanceof BinaryPrefixComparator); + BinaryPrefixComparator binaryPrefixComparator = + (BinaryPrefixComparator) familyFilter.getComparator(); + assertEquals("pre", new String(binaryPrefixComparator.getValue())); + } + + @Test + public void testQualifierFilter() throws IOException { + String filterString = "QualifierFilter(=, 'regexstring:pre*')"; + QualifierFilter qualifierFilter = + doTestFilter(filterString, QualifierFilter.class); + assertEquals(CompareFilter.CompareOp.EQUAL, qualifierFilter.getOperator()); + assertTrue(qualifierFilter.getComparator() instanceof RegexStringComparator); + RegexStringComparator regexStringComparator = + (RegexStringComparator) qualifierFilter.getComparator(); + assertEquals("pre*", new String(regexStringComparator.getValue())); + } + + @Test + public void testValueFilter() throws IOException { + String filterString = "ValueFilter(!=, 'substring:pre')"; + ValueFilter valueFilter = + doTestFilter(filterString, ValueFilter.class); + assertEquals(CompareFilter.CompareOp.NOT_EQUAL, valueFilter.getOperator()); + assertTrue(valueFilter.getComparator() instanceof SubstringComparator); + SubstringComparator substringComparator = + (SubstringComparator) valueFilter.getComparator(); + assertEquals("pre", new String(substringComparator.getValue())); + } + + @Test + public void testColumnRangeFilter() throws IOException { + String filterString = "ColumnRangeFilter('abc', true, 'xyz', false)"; + ColumnRangeFilter columnRangeFilter = + doTestFilter(filterString, ColumnRangeFilter.class); + assertEquals("abc", new String(columnRangeFilter.getMinColumn())); + assertEquals("xyz", new String(columnRangeFilter.getMaxColumn())); + assertTrue(columnRangeFilter.isMinColumnInclusive()); + assertFalse(columnRangeFilter.isMaxColumnInclusive()); + } + + @Test + public void testDependentColumnFilter() throws IOException { + String filterString = "DependentColumnFilter('family', 'qualifier', true, =, 'binary:abc')"; + DependentColumnFilter dependentColumnFilter = + doTestFilter(filterString, DependentColumnFilter.class); + assertEquals("family", new String(dependentColumnFilter.getFamily())); + assertEquals("qualifier", new String(dependentColumnFilter.getQualifier())); + assertTrue(dependentColumnFilter.getDropDependentColumn()); + assertEquals(CompareFilter.CompareOp.EQUAL, dependentColumnFilter.getOperator()); + assertTrue(dependentColumnFilter.getComparator() instanceof BinaryComparator); + BinaryComparator binaryComparator = (BinaryComparator)dependentColumnFilter.getComparator(); + assertEquals("abc", new String(binaryComparator.getValue())); + } + + @Test + public void testSingleColumnValueFilter() throws IOException { + String filterString = "SingleColumnValueFilter " + + "('family', 'qualifier', >=, 'binary:a', true, false)"; + SingleColumnValueFilter singleColumnValueFilter = + doTestFilter(filterString, SingleColumnValueFilter.class); + assertEquals("family", new String(singleColumnValueFilter.getFamily())); + assertEquals("qualifier", new String(singleColumnValueFilter.getQualifier())); + assertEquals(singleColumnValueFilter.getOperator(), CompareFilter.CompareOp.GREATER_OR_EQUAL); + assertTrue(singleColumnValueFilter.getComparator() instanceof BinaryComparator); + BinaryComparator binaryComparator = (BinaryComparator) singleColumnValueFilter.getComparator(); + assertEquals(new String(binaryComparator.getValue()), "a"); + assertTrue(singleColumnValueFilter.getFilterIfMissing()); + assertFalse(singleColumnValueFilter.getLatestVersionOnly()); + + + filterString = "SingleColumnValueFilter ('family', 'qualifier', >, 'binaryprefix:a')"; + singleColumnValueFilter = doTestFilter(filterString, SingleColumnValueFilter.class); + assertEquals("family", new String(singleColumnValueFilter.getFamily())); + assertEquals("qualifier", new String(singleColumnValueFilter.getQualifier())); + assertEquals(singleColumnValueFilter.getOperator(), CompareFilter.CompareOp.GREATER); + assertTrue(singleColumnValueFilter.getComparator() instanceof BinaryPrefixComparator); + BinaryPrefixComparator binaryPrefixComparator = + (BinaryPrefixComparator) singleColumnValueFilter.getComparator(); + assertEquals(new String(binaryPrefixComparator.getValue()), "a"); + assertFalse(singleColumnValueFilter.getFilterIfMissing()); + assertTrue(singleColumnValueFilter.getLatestVersionOnly()); + } + + @Test + public void testSingleColumnValueExcludeFilter() throws IOException { + String filterString = + "SingleColumnValueExcludeFilter ('family', 'qualifier', <, 'binaryprefix:a')"; + SingleColumnValueExcludeFilter singleColumnValueExcludeFilter = + doTestFilter(filterString, SingleColumnValueExcludeFilter.class); + assertEquals(singleColumnValueExcludeFilter.getOperator(), CompareFilter.CompareOp.LESS); + assertEquals("family", new String(singleColumnValueExcludeFilter.getFamily())); + assertEquals("qualifier", new String(singleColumnValueExcludeFilter.getQualifier())); + assertEquals(new String(singleColumnValueExcludeFilter.getComparator().getValue()), "a"); + assertFalse(singleColumnValueExcludeFilter.getFilterIfMissing()); + assertTrue(singleColumnValueExcludeFilter.getLatestVersionOnly()); + + filterString = "SingleColumnValueExcludeFilter " + + "('family', 'qualifier', <=, 'binaryprefix:a', true, false)"; + singleColumnValueExcludeFilter = + doTestFilter(filterString, SingleColumnValueExcludeFilter.class); + assertEquals("family", new String(singleColumnValueExcludeFilter.getFamily())); + assertEquals("qualifier", new String(singleColumnValueExcludeFilter.getQualifier())); + assertEquals(singleColumnValueExcludeFilter.getOperator(), + CompareFilter.CompareOp.LESS_OR_EQUAL); + assertTrue(singleColumnValueExcludeFilter.getComparator() instanceof BinaryPrefixComparator); + BinaryPrefixComparator binaryPrefixComparator = + (BinaryPrefixComparator) singleColumnValueExcludeFilter.getComparator(); + assertEquals(new String(binaryPrefixComparator.getValue()), "a"); + assertTrue(singleColumnValueExcludeFilter.getFilterIfMissing()); + assertFalse(singleColumnValueExcludeFilter.getLatestVersionOnly()); + } + + @Test + public void testSkipFilter() throws IOException { + String filterString = "SKIP ValueFilter( =, 'binary:0')"; + SkipFilter skipFilter = + doTestFilter(filterString, SkipFilter.class); + assertTrue(skipFilter.getFilter() instanceof ValueFilter); + ValueFilter valueFilter = (ValueFilter) skipFilter.getFilter(); + + assertEquals(CompareFilter.CompareOp.EQUAL, valueFilter.getOperator()); + assertTrue(valueFilter.getComparator() instanceof BinaryComparator); + BinaryComparator binaryComparator = (BinaryComparator) valueFilter.getComparator(); + assertEquals("0", new String(binaryComparator.getValue())); + } + + @Test + public void testWhileFilter() throws IOException { + String filterString = " WHILE RowFilter ( !=, 'binary:row1')"; + WhileMatchFilter whileMatchFilter = + doTestFilter(filterString, WhileMatchFilter.class); + assertTrue(whileMatchFilter.getFilter() instanceof RowFilter); + RowFilter rowFilter = (RowFilter) whileMatchFilter.getFilter(); + + assertEquals(CompareFilter.CompareOp.NOT_EQUAL, rowFilter.getOperator()); + assertTrue(rowFilter.getComparator() instanceof BinaryComparator); + BinaryComparator binaryComparator = (BinaryComparator) rowFilter.getComparator(); + assertEquals("row1", new String(binaryComparator.getValue())); + } + + @Test + public void testCompoundFilter1() throws IOException { + String filterString = " (PrefixFilter ('realtime')AND FirstKeyOnlyFilter())"; + FilterList filterList = + doTestFilter(filterString, FilterList.class); + ArrayList filters = (ArrayList) filterList.getFilters(); + + assertTrue(filters.get(0) instanceof PrefixFilter); + assertTrue(filters.get(1) instanceof FirstKeyOnlyFilter); + PrefixFilter PrefixFilter = (PrefixFilter) filters.get(0); + byte [] prefix = PrefixFilter.getPrefix(); + assertEquals(new String(prefix), "realtime"); + FirstKeyOnlyFilter firstKeyOnlyFilter = (FirstKeyOnlyFilter) filters.get(1); + } + + @Test + public void testCompoundFilter2() throws IOException { + String filterString = "(PrefixFilter('realtime') AND QualifierFilter (>=, 'binary:e'))" + + "OR FamilyFilter (=, 'binary:qualifier') "; + FilterList filterList = + doTestFilter(filterString, FilterList.class); + ArrayList filterListFilters = (ArrayList) filterList.getFilters(); + assertTrue(filterListFilters.get(0) instanceof FilterList); + assertTrue(filterListFilters.get(1) instanceof FamilyFilter); + assertEquals(filterList.getOperator(), FilterList.Operator.MUST_PASS_ONE); + + filterList = (FilterList) filterListFilters.get(0); + FamilyFilter familyFilter = (FamilyFilter) filterListFilters.get(1); + + filterListFilters = (ArrayList)filterList.getFilters(); + assertTrue(filterListFilters.get(0) instanceof PrefixFilter); + assertTrue(filterListFilters.get(1) instanceof QualifierFilter); + assertEquals(filterList.getOperator(), FilterList.Operator.MUST_PASS_ALL); + + assertEquals(CompareFilter.CompareOp.EQUAL, familyFilter.getOperator()); + assertTrue(familyFilter.getComparator() instanceof BinaryComparator); + BinaryComparator binaryComparator = (BinaryComparator) familyFilter.getComparator(); + assertEquals("qualifier", new String(binaryComparator.getValue())); + + PrefixFilter prefixFilter = (PrefixFilter) filterListFilters.get(0); + byte [] prefix = prefixFilter.getPrefix(); + assertEquals(new String(prefix), "realtime"); + + QualifierFilter qualifierFilter = (QualifierFilter) filterListFilters.get(1); + assertEquals(CompareFilter.CompareOp.GREATER_OR_EQUAL, qualifierFilter.getOperator()); + assertTrue(qualifierFilter.getComparator() instanceof BinaryComparator); + binaryComparator = (BinaryComparator) qualifierFilter.getComparator(); + assertEquals("e", new String(binaryComparator.getValue())); + } + + @Test + public void testCompoundFilter3() throws IOException { + String filterString = " ColumnPrefixFilter ('realtime')AND " + + "FirstKeyOnlyFilter() OR SKIP FamilyFilter(=, 'substring:hihi')"; + FilterList filterList = + doTestFilter(filterString, FilterList.class); + ArrayList filters = (ArrayList) filterList.getFilters(); + + assertTrue(filters.get(0) instanceof FilterList); + assertTrue(filters.get(1) instanceof SkipFilter); + + filterList = (FilterList) filters.get(0); + SkipFilter skipFilter = (SkipFilter) filters.get(1); + + filters = (ArrayList) filterList.getFilters(); + assertTrue(filters.get(0) instanceof ColumnPrefixFilter); + assertTrue(filters.get(1) instanceof FirstKeyOnlyFilter); + + ColumnPrefixFilter columnPrefixFilter = (ColumnPrefixFilter) filters.get(0); + byte [] columnPrefix = columnPrefixFilter.getPrefix(); + assertEquals(new String(columnPrefix), "realtime"); + + FirstKeyOnlyFilter firstKeyOnlyFilter = (FirstKeyOnlyFilter) filters.get(1); + + assertTrue(skipFilter.getFilter() instanceof FamilyFilter); + FamilyFilter familyFilter = (FamilyFilter) skipFilter.getFilter(); + + assertEquals(CompareFilter.CompareOp.EQUAL, familyFilter.getOperator()); + assertTrue(familyFilter.getComparator() instanceof SubstringComparator); + SubstringComparator substringComparator = + (SubstringComparator) familyFilter.getComparator(); + assertEquals("hihi", new String(substringComparator.getValue())); + } + + @Test + public void testCompoundFilter4() throws IOException { + String filterString = " ColumnPrefixFilter ('realtime') OR " + + "FirstKeyOnlyFilter() OR SKIP FamilyFilter(=, 'substring:hihi')"; + FilterList filterList = + doTestFilter(filterString, FilterList.class); + ArrayList filters = (ArrayList) filterList.getFilters(); + + assertTrue(filters.get(0) instanceof ColumnPrefixFilter); + assertTrue(filters.get(1) instanceof FirstKeyOnlyFilter); + assertTrue(filters.get(2) instanceof SkipFilter); + + ColumnPrefixFilter columnPrefixFilter = (ColumnPrefixFilter) filters.get(0); + FirstKeyOnlyFilter firstKeyOnlyFilter = (FirstKeyOnlyFilter) filters.get(1); + SkipFilter skipFilter = (SkipFilter) filters.get(2); + + byte [] columnPrefix = columnPrefixFilter.getPrefix(); + assertEquals(new String(columnPrefix), "realtime"); + + assertTrue(skipFilter.getFilter() instanceof FamilyFilter); + FamilyFilter familyFilter = (FamilyFilter) skipFilter.getFilter(); + + assertEquals(CompareFilter.CompareOp.EQUAL, familyFilter.getOperator()); + assertTrue(familyFilter.getComparator() instanceof SubstringComparator); + SubstringComparator substringComparator = + (SubstringComparator) familyFilter.getComparator(); + assertEquals("hihi", new String(substringComparator.getValue())); + } + + @Test + public void testIncorrectCompareOperator() throws IOException { + String filterString = "RowFilter ('>>' , 'binary:region')"; + try { + doTestFilter(filterString, RowFilter.class); + assertTrue(false); + } catch (IllegalArgumentException e) { + System.out.println("Incorrect compare operator >>"); + } + } + + @Test + public void testIncorrectComparatorType () throws IOException { + String filterString = "RowFilter ('>=' , 'binaryoperator:region')"; + try { + doTestFilter(filterString, RowFilter.class); + assertTrue(false); + } catch (IllegalArgumentException e) { + System.out.println("Incorrect comparator type: binaryoperator"); + } + + filterString = "RowFilter ('>=' 'regexstring:pre*')"; + try { + doTestFilter(filterString, RowFilter.class); + assertTrue(false); + } catch (IllegalArgumentException e) { + System.out.println("RegexStringComparator can only be used with EQUAL or NOT_EQUAL"); + } + + filterString = "SingleColumnValueFilter" + + " ('family', 'qualifier', '>=', 'substring:a', 'true', 'false')')"; + try { + doTestFilter(filterString, RowFilter.class); + assertTrue(false); + } catch (IllegalArgumentException e) { + System.out.println("SubtringComparator can only be used with EQUAL or NOT_EQUAL"); + } + } + + @Test + public void testPrecedence1() throws IOException { + String filterString = " (PrefixFilter ('realtime')AND FirstKeyOnlyFilter()" + + " OR KeyOnlyFilter())"; + FilterList filterList = + doTestFilter(filterString, FilterList.class); + + ArrayList filters = (ArrayList) filterList.getFilters(); + + assertTrue(filters.get(0) instanceof FilterList); + assertTrue(filters.get(1) instanceof KeyOnlyFilter); + + filterList = (FilterList) filters.get(0); + filters = (ArrayList) filterList.getFilters(); + + assertTrue(filters.get(0) instanceof PrefixFilter); + assertTrue(filters.get(1) instanceof FirstKeyOnlyFilter); + + PrefixFilter prefixFilter = (PrefixFilter)filters.get(0); + byte [] prefix = prefixFilter.getPrefix(); + assertEquals(new String(prefix), "realtime"); + } + + @Test + public void testPrecedence2() throws IOException { + String filterString = " PrefixFilter ('realtime')AND SKIP FirstKeyOnlyFilter()" + + "OR KeyOnlyFilter()"; + FilterList filterList = + doTestFilter(filterString, FilterList.class); + ArrayList filters = (ArrayList) filterList.getFilters(); + + assertTrue(filters.get(0) instanceof FilterList); + assertTrue(filters.get(1) instanceof KeyOnlyFilter); + + filterList = (FilterList) filters.get(0); + filters = (ArrayList) filterList.getFilters(); + + assertTrue(filters.get(0) instanceof PrefixFilter); + assertTrue(filters.get(1) instanceof SkipFilter); + + PrefixFilter prefixFilter = (PrefixFilter)filters.get(0); + byte [] prefix = prefixFilter.getPrefix(); + assertEquals(new String(prefix), "realtime"); + + SkipFilter skipFilter = (SkipFilter)filters.get(1); + assertTrue(skipFilter.getFilter() instanceof FirstKeyOnlyFilter); + } + + @Test + public void testUnescapedQuote1 () throws IOException { + String filterString = "InclusiveStopFilter ('row''3')"; + InclusiveStopFilter inclusiveStopFilter = + doTestFilter(filterString, InclusiveStopFilter.class); + byte [] stopRowKey = inclusiveStopFilter.getStopRowKey(); + assertEquals(new String(stopRowKey), "row'3"); + } + + @Test + public void testUnescapedQuote2 () throws IOException { + String filterString = "InclusiveStopFilter ('row''3''')"; + InclusiveStopFilter inclusiveStopFilter = + doTestFilter(filterString, InclusiveStopFilter.class); + byte [] stopRowKey = inclusiveStopFilter.getStopRowKey(); + assertEquals(new String(stopRowKey), "row'3'"); + } + + @Test + public void testUnescapedQuote3 () throws IOException { + String filterString = " InclusiveStopFilter ('''')"; + InclusiveStopFilter inclusiveStopFilter = + doTestFilter(filterString, InclusiveStopFilter.class); + byte [] stopRowKey = inclusiveStopFilter.getStopRowKey(); + assertEquals(new String(stopRowKey), "'"); + } + + @Test + public void testIncorrectFilterString () throws IOException { + String filterString = "()"; + byte [] filterStringAsByteArray = Bytes.toBytes(filterString); + try { + filter = f.parseFilterString(filterStringAsByteArray); + assertTrue(false); + } catch (IllegalArgumentException e) { + System.out.println(e.getMessage()); + } + } + + @Test + public void testCorrectFilterString () throws IOException { + String filterString = "(FirstKeyOnlyFilter())"; + FirstKeyOnlyFilter firstKeyOnlyFilter = + doTestFilter(filterString, FirstKeyOnlyFilter.class); + } + + private T doTestFilter(String filterString, Class clazz) throws IOException { + byte [] filterStringAsByteArray = Bytes.toBytes(filterString); + filter = f.parseFilterString(filterStringAsByteArray); + assertEquals(clazz, filter.getClass()); + return clazz.cast(filter); + } +}